Az objektum-orientált C++ nyelvben az érték és referencia szerinti paraméterátadás még a másoló konstruktorok gondolatával egészül ki. A referencia szerint adunk át valamelyik függvénynek egy objektumot, akkor magát az objektumot kapja meg (pontosan azt az objektumot, amelyiket paraméterben adtuk neki); ha érték szerint, akkor az objektumnak csak a másolatát. Hogyan képződik egy objektumnak a másolata? Természetesen annak másoló konstruktorával. A függvény végén pedig megszűnnek annak lokális objektumai. Érték szerinti paraméterátadás esetén ez azt jelenti, hogy az objektum másolata megszűnik, vagyis a destruktora le fog futni. Referencia szerinti átadásnál ilyenkor nem történik vele semmi, mert nem lokális változója volt, továbbra is léteznie kell majd.
Hogy egy függvénynek egy objektumot másolatként vagy referenciaként adunk át, az attól függ, mit szeretnénk csinálni vele:
- Ha érték szerint veszi át a függvény, akkor akár meg is változtathatja, azzal az eredeti objektumra nem lesz hatással. Ez például egy munkamásolat lehet. Ha ilyenre van szükség, akkor mindenképpen értékként kell átvenni az objektumot.
- Ha referencia szerinti a függvény paramétere, akkor az eredetit látja, és azon tud dolgozni, ilyenkor viszont az eredeti objektum is megváltozhat. Ha erre van szükség, akkor mindenképpen a referencia szerint átadást kell választani.
- Ha nem szeretnénk se megváltoztatni, se lemásolni az objektumot, akkor általában konstans referenciával vesszük át.
Az érték szerinti átadás esetén az objektumnak a másoló konstruktora és a destruktora futni fog. Ez hosszú idő lehet. Ha a másolás számunkra fölösleges, akkor érdemes inkább referencia szerint átvenni az objektumot, mert sokkal gyorsabb lehet a program. Ha referencia szerint vesszük át, akkor vigyázni kell, nehogy szándékolatlanul megváltoztassuk annak állapotát. Ezért objektumokat gyakran konstans referenciával kell átvenni; a konstans kulcsszó hatására a fordító ellenőrizni fogja, hogy változtatást biztos ne végezzünk rajta. Mivel a beépített típusok (pl. char, int) kicsik, ezért azokat, ha nem szükséges a függvénynek megváltoztatnia az eredeti változókat, érték szerint szokás átvenni – mert a másolásuk gyors, destruktoruk nincs.
Előfordulhat néhány eset, amikor pedig egy objektumot csak referencia szerint tudunk átvenni – névlegesen, amikor az objektumnak nincs másoló konstruktora. Ilyen osztály például az std::ostream, amelyik egy nyitott fájlt jelképez. Ennek nincs másoló konstruktora, mivel értelmetlen lenne. Ezért az std::cout-ot mindig referenciaként tudjuk csak átvenni. Másik ilyen eset az pedig az osztályok másoló konstruktora maga. Ezeknek a lemásolandó objektumot muszáj referencia szerint átvenniük, mivel ha érték szerint vennék át, akkor ahhoz pont a másoló konstruktorra lenne szükség, vagyis végtelen ciklus keletkezne.
Ha referenciaként veszünk át egy objektumot, akkor még konstans esetén is gondolnunk kell arra, hogy a paraméterben az eredeti objektumot látjuk. Ez például akkor válhat érdekessé, amikor egy osztály tagfüggvénye saját típusú objektumot vár paraméterben. Leggyakoribb példa erre az osztályok értékadó operátora:
class Sztring {
char *szo;
public:
Sztring& operator=(const Sztring& s) {
if (this != &s) {
delete[] szo;
szo = new char[strlen(s.szo)+1];
strcpy(szo, s.szo);
}
return *this;
}
};
Sztring x;
x = x;Mivel a függvény a paraméterben olyan fajta objektumot vár, mint saját maga, előfordulhat az, hogy pontosan saját magát kapja meg. Ilyenkor a this ugyanarra az objektumra mutat, mint ami paraméterként s-ben jött, vagyis a delete[] szo sorral igazából s-nek a szo tömbjét „is” felszabadítjuk. Ezért van szükség annak ellenőrzésére, hogy a this ugyanaz az objektum-e, mint a paraméterben kapott – nem csak hogy egyformák-e, hanem ugyanazok-e. A másoló konstruktorban erre azért nem volt szükség, mert az éppen létrehozott objektum úgysem ugyanaz, mint bármelyik eddigi. Az értékadó operátor is átvehetné másolatként az egyenlőség jel jobb oldalán álló objektumot (feltéve persze, hogy a másoló konstruktort nem erre vezettük vissza):
Sztring& operator=(Sztring s);Ez egy tulajdonképpen működő, de hatékonyság szempontjából nem túl jó megoldás. Ugyanis ilyenkor a lemásolandó sztring először lemásolódik (mivel az értékparaméter másolatként kerül a függvényhez); utána a függvény a lemásolt sztringből másolná át saját magához a tartalmat, végül a másolat megszűnik a destruktorával. Ugyan ilyenkor nem kellene a this != &s ellenőrzés (mivel a másolat úgysem ugyanaz, mint saját maga), de az objektum létrehozása és törlése sok ideig tarthat.
Mindez egyébként a pointerekre is igaz. A következő problémára futottam rá egyszer C-ben:
char *legutobbi_fajl = NULL; void legutobbi_fajl_beallit(const char *nev) { if (legutobbi_fajl) { free(legutobbi_fajl); // 1 } legutobbi_fajl = malloc(strlen(nev)+1); strcpy(legutobbi_fajl, nev); } void fajl_beolvas(const char *nev) { ... legutobbi_fajl_beallit(nev); } ... fajl_beolvas(legutobbi_fajl); // 2A hiba helye nem volt triviális, mivel a lefagyást közvetetten kiváltó programrész távol volt a lefagyás tényleges helyétől (ráadásul más forrás fájlban). Az 1-es sor felel meg a sztringes példa
delete[] szosorának, a 2-es sor pedig azx=xönértékadásnak. Látszik, hogy az egész kód célja, hogy a sort be lehessen írni, azt a magától értetődő feladatot elvégezni vele, hogy megnyitja a legutóbb használt fájlt. A sztring érték szerinti átadására persze C-ben esély sincs.
A visszatérési értékek referencia vagy másolat szerinti átadása is eldönthető egyszerűen. A „lokális változóra nem lehet pointert adni” szabály helyett sokkal szemléletesebb arra gondolni, hogy a visszaadott objektum új, vagy már eddig is létezett:
class Komplex {
double re, im;
...
};
Komplex Komplex::operator+(const Komplex& rhs) const {
Komplex osszeg;
osszeg.re = this->re+rhs.re;
osszeg.im = this->im+rhs.im;
return osszeg;
}
Komplex& Komplex::operator+=(const Komplex& rhs) {
this->re += rhs.re;
this->im += lhs.im;
return *this;
} Az összeadásnál egy új szám keletkezik. A növelésnél az operátor bal oldalán álló szám megváltozik, visszatérni pedig pont azzal kell, új objektum értelemszerűen nem keletkezik.
