C# ben a string meg az obj típús miért referencia típúsok? Példa lent.
Példa.
Egy class al létrehozott típús az referencia típús mert ha azokat egymáshoz rendeljük,akkor nem az értékét veszi fel az ami ball oldalt van hanem a referenciáját tehát a jobb oldali egy alias lesz a bal oldalira.
Kóddal:
class MyClass {
public ushort x;
}
class Program {
static void main(String [] args) {
MyClass q, m;
q.x = 5;
m.x = 10;
q = m; //q egy alias lesz m-re,mert ezek referencia típúsok.
q.x = 5555;
System.Console.WriteLine(m.x); //m.x értéke 5555 mert ha q változik akkor m is.
}
}
Amit nem értek az az,hogy a jegyzet szerint a String és az Object is referencia típúsok ha ez igaz,akkor miért van az,hogy amikor egy string,vagy Object típúst egymáshoz rendelek,akkor csak egymás értékeit veszik fel.
Erre az a bizonyíték,hogy mindig csak az egyik változik.
Példa a bedobozolásra(Arra van,hogy egy érték típúst referencia típúsként tudjak kezelni)de nem tudom így kezelni őket mert mindig csak érték szerint történik itt is mint a stringek esetében.
int x = 5, y = 10;
Object ox = x; //Bedobozolás
Object oy = y; //Szintén
//Mivel az Object referencia típús nem érték szerinti átadásnak kéne történnie de sajnos az történik:
ox = oy;
ox = 45;
WriteLine(oy); //oy nem lett 45 mert nem kapta meg ox az oy refereniáját csak az értékét.
Stringnél szintén:
string s1 = "bb", s2 = "kk";
s1 = s2; //s1 nem veszi fel s2 referenciáját nem lesz rá alias mégis referencia típúsok miért?
s1 = "jjjj";
WriteLine(s2); //s2 nem lett jjjj;
Hogy van ez?Miért referencia típúsok mikor érték szerint működnek?
Mi értelme van akkor a bedobozolásnak,ha mégsem tudom referencia szerint használni a numerikus típúsokat?
Hogy van ez már?
Jólvan értem(Típus).
Ezen kívül szerintetek mi lehet a baj miért mondják őket referencia típusnak ha nem is úgy viselkednek?
válasza:nem teljesen értem mi a problémád meg c# ot sem ismerem, viszont ezek:
int x = 5, y = 10;
Object ox = x;
Object oy = y;
ox = oy; // talán ha ezt fordítva írod oy=ox; így oy veszi fel ox értékét.
ox = 45;
WriteLine(oy); // oy nak y t adtad értékül és annyi, nem meglepő többet nem változott
string s1 = "bb", s2 = "kk";
s1 = s2; // nem inkább s2=s1; s2 vegye fel s2 értékét ne fordítva...
s1 = "jjjj";
WriteLine(s2); //itt is s2 nek egyszer adsz értéket aztán hagyod.
nem ismerem c# ot de ilyen ilyen alapvető dolog, baloldalt van aminek értéket adunk nem hiszem változott. de ha mégis akkor bocs a baromságokért:D
válasza:Gondolkodj. Miért nem viselkednek úgy?
Vegyük a stringes példádat.
string s1 = "bb", s2 = "kk";
s1 = s2; //s1 nem veszi fel s2 referenciáját nem lesz rá alias mégis referencia típúsok miért?
s1 = "jjjj";
A memóriában létezik egy "bb", egy "kk" és egy "jjjj" string.
Az első sor után s1 a "bb"-re, s2 pedig a "kk"-ra mutat.
A második sor után s1 átállítódik s2 értékére, tehát ugyanoda fog mutatni, "kk"-ra.
A harmadik sor pedig átállítja s1-et, és "jjjj"-re fog mutatni.
Ha megnézed, egyszer sem MÓDOSÍTOD a stringet, mindig csak értéket adsz a referenciának. Azért lehet ilyen illúziód, mert a string immutable, nem lehet megváltoztatni az értékét. Egy string az az, ami. Ha mást akarsz, akkor elő kell állítani egy újat, nem tudod a létező módosítani. A számok is ugyanígy viselkednek, ha elképzeled: felteheted, hogy létezik minden egész a memóriában, a számok pedig csak valamelyikre mutatnak. Ez persze nem így van, hatékonysági és megvalósíthatósági okokból, de gondolhatsz rá így.
iostream épp ez a baj,hogy csak az értékét kapja meg.
A második sor után s1 átállítódik s2 értékére, tehát ugyanoda fog mutatni, "kk"-ra.
Az a baj,hogy s1 az s2 értékét kapja meg.
Pedig a string referencia típus és mégis érték szerinti átadás történik.
class x { int y }
x a;
x b;
a.x = 5;
b.x = 6;
a = b; //A classal létrehozott típus is ref típus ezért nem az értékét fogja megkapni hanem a címét.
Ezért van az ,hogy ha a.x et megváltoztatom akkor b.x is változik.
És a string esetében is a címét kéne megkapnia mert úgy van írva,hogy a string az ref típus.
Értitek már????
Értem amit írtál iostrem.
Akkor ez ugyanaz:
int x = 5, y = 10;
x = y;
Az 'x' 10 re fog mutatni mert felveszi az y értékét.
Ugyanaz történik string és int esetében is de a string az ref típus csak nem tudom miért.
Láthattuk,hogy a class nál más ha átnézitek a string és class példákat akkor láthassátok,hogy nem ugyanaz történik.
válasza:A stringet egyébként sem fogod tudni megváltoztatni, mert immutable. Csak úgy tudod a stringet megváltozttatni, ha új példányt készítesz. Ezért van pl, hogy a replace nem a meglévő stringben cserél ki, hanem egy uj stringet ad vissza.
Nézzük a példád, és tegyük fel, hogy a string nem lenne immutable, és lenne egy x metódusa, ami hozzáfűz egy X betűt, ekkor:
string s1 = "bb", s2 = "kk";
s1 = s2;
s1.x();
WriteLine(s2); //kkX;
válasza: válasza:iostream mindent leírt, abból meg kell, hogy értsd.
És szokj hozzá, sajnos ez a C#-nak egy nagy hülyesége, hogy nem te döntöd el, hogy mit hogy használsz, referenciaként vagy értékként, hanem helyette bevezették ezt a value type reference type dolgot, és még ezt is meghülyítették az immutable class-okkal :D
Kíváncsi lennék, vajon mi oka volt ennek, de jobban örültem volna, ha megmarad a C++-os megközelítés, ahol én döntöm el, hogy értékként vagy referenciaként használok valamit.
Kapcsolódó kérdések:
Minden jog fenntartva © 2024, www.gyakorikerdesek.hu
GYIK | Szabályzat | Jogi nyilatkozat | Adatvédelem | Cookie beállítások | WebMinute Kft. | Facebook | Kapcsolat: info(kukac)gyakorikerdesek.hu
Ha kifogással szeretne élni valamely tartalommal kapcsolatban, kérjük jelezze e-mailes elérhetőségünkön!