Mi van C++-ban a C#-os "out" helyett?

C#-ban a garbage collection miatt nem szabad pointereket használni. Ennek a nehézségnek a megkerülésére találták ki az 'out' és 'ref' kulcsszavakat.

Plusz ott vannak még a value type-ok és reference type-ok, de nagyon nem akarok belemenni, ha C#-ozol, valszeg tisztában vagy ezekkel.

C++-ban viszont nincsenek megkülönböztetve value és reference type-ok, bármilyen típussal dolgozhatsz értékként és referenciaként is. Azaz nyugodtan használhatsz pointereket, tehát ha azt akarod elérni, mint C#-ban az out-tal, akkor az pl. így néz ki:

void increment(int* int_valtozo_cime)

{

(*int_valtozo_cime)++;

}

Itt a * az int után azt jelenti, hogy egy int típusú változó memóriacímét várod paraméterként, azaz a függvényben megváltoztathatod a memóriacímen lévő értéket.

Amikor meghívod:

int egesz = 1;

increment(&egesz);

//Ezen a ponton 'egesz' értéke már 2 lesz

Többet már lusta vagyok írni, nézz utána a C++ pointereknek :)

Így is meg lehet oldani:

void incr(int &a)

{

a++;

}

incr(x); // ilyenkor nem kell a &

Annyira nem értelmezted rosszul :)

Kicsit zavaros ez a dolog C#-ban, főleg, ha előtte már hozzászoktál a C++-hoz, de megpróbálom elmagyarázni C++ alapokon.

Alapvetően azt kell megérteni C#-ban, hogy vannak value type-ok, és vannak reference type-ok.

1. Minden primitív típus(tehát int, bool, char, stb.) value type, ami azt jelenti, hogy érték szerint adódik át paraméter-átadás során, azaz az eredeti változót nem tudod módosítani.

2. Minden struct value type.

3. Minden class reference type, ami azt jelenti, hogy C++-ra lefordítva const pointer-ként adódnak át paraméter-átadás során, azaz: nem tudod megváltoztatni azt, hogy a pointer mire mutat, de módosíthatod magát az objektumot, amire mutat.

Na és itt jön képbe az out kulcsszó, ami meg kb. úgy funkcionál, mint pointerre mutató pointer, azaz:

a. megváltoztathatod azt is, hogy a pointer mire mutasson

b. és természetesen az objektumot is magát, amire mutat.

Persze mivel az out-ot arra használják, hogy értéket kapjanak vissza, egy null-ra inicializált referenciát szoktak átadni oda, ahol az out paraméter van, így a b. esetnek a gyakorlatban nincs jelentősége.

Egy példa:

class PeldaClass

{

//Valami van benne, tökmindegy, mi

public int szam=0;

}

void main()

{

Class myPC = new PeldaClass();

fuggveny1(myPC);

//myPC.szam értéke 1 lesz

fuggveny2(myPC);

//myPC által mutatott objektum nem változott,

//szám értéke még mindig 1 lesz

fuggveny3(out myPC);

//a myPC mutató a át lett állítva egy új objektumra

//(a régit majd elintézi a GC), myPC.szam értéke 3

}

void fuggveny1(PeldaClass pc)

{

pc.szam = 1;

}

void fuggveny2(PeldaClass pc)

{

pc = new PeldaClass();

pc.szam = 2;

//Itt nem az eredeti mutatót változtatod, hanem a

//mutató másolatát, így az eredeti objektumra nem lesz

//hatással

}

void fuggveny2(out PeldaClass pc)

{

pc = new PeldaClass();

pc.szam = 3;

//itt megváltoztathatod, hogy mire mutasson

//a kapott referencia, sőt, a függvény törzsében

//legalább 1x meg is kell tenned, mert különben

//compile error

}

Az 'out' paraméter az kb. ugyanaz, mintha egy pointer-t adnál át, és függvényben beállíthatod, hogy az a pointer mire mutasson.