reference (tsz. references)
A referencia (reference) a C++ egyik fontos fogalma, amely lehetővé teszi, hogy egy változóra egy másik névvel hivatkozzunk anélkül, hogy új példányt hoznánk létre. Ez különösen hasznos memóriahatékonyság szempontjából, mivel elkerülhetjük az objektumok felesleges másolását.
A referencia egy másik változóra mutató alternatív név. Ha egy referenciát egy változóhoz kötünk, azután a referencia és az eredeti változó ugyanazt az adatot jelenti, bármelyik néven is érjük el.
A referenciákat az & (és jelkent ismert ampersand) operátorral deklarálhatjuk:
int a = 10;
int& ref = a; // ref mostantól egy referencia 'a'-ra
Ebben a példában: - ref nem egy új változó, hanem egy másik név az a változóra. - Ha ref értékét megváltoztatjuk, akkor a értéke is módosul, mivel ugyanarra a memóriaterületre mutatnak.
#include <iostream>
using namespace std;
int main() {
int szam = 42;
int& ref = szam; // referencia létrehozása
cout << "szam: " << szam << ", ref: " << ref << endl;
ref = 100; // módosítjuk a referencia értékét
cout << "szam módosítva: " << szam << endl; // 'szam' is megváltozik!
return 0;
}
Kimenet:
szam: 42, ref: 42 szam módosítva: 100
A ref és szam ugyanarra a memóriaterületre mutat, így bármelyik változó módosítása a másikra is hatással lesz.
A referenciák nagyon gyakran használtak függvényparaméterként, mert lehetővé teszik az adatok átadását másolás nélkül.
Ha egy változót referenciaként adunk át egy függvénynek, akkor az a függvényen belül is módosítható lesz, anélkül, hogy másolat készülne róla.
void novel(int& x) {
x += 10; // Az x változó módosul, mivel referenciaként kaptuk meg
}
int main() {
int ertek = 5;
novel(ertek);
cout << "ertek: " << ertek << endl; // 15 lesz az értéke
return 0;
}
Itt a novel függvény közvetlenül módosítja az ertek változót.
Ha nem referenciát használnánk, hanem érték szerinti paraméterátadást:
void novel(int x) { // NEM referencia
x += 10;
}
Ebben az esetben a novel(ertek); meghívása nem változtatná meg az ertek értékét, mert az x csak egy másolat lenne.
Ha nem akarjuk, hogy a függvény módosítsa a bemeneti paramétert, használhatunk konstans referenciát (const &).
void kiir(const int& x) {
cout << "Érték: " << x << endl;
}
int main() {
int szam = 20;
kiir(szam);
return 0;
}
Itt a const int& x azt biztosítja, hogy x értéke ne legyen módosítható a függvényen belül. Ez különösen akkor hasznos, ha nagy objektumokat szeretnénk átadni a függvényeknek anélkül, hogy lemásolnánk őket.
A függvények referenciát is visszaadhatnak, amely lehetővé teszi az eredeti változó módosítását.
int& visszaadReferencia(int& x) {
return x;
}
int main() {
int szam = 50;
int& ref = visszaadReferencia(szam);
ref += 10;
cout << "szam: " << szam << endl; // 60 lesz az értéke
return 0;
}
Ebben az esetben a visszaadReferencia függvény egy referencia visszatéréseként adja vissza az x változót.
Nem szabad olyan függvényből referenciát visszaadni, amely egy lokális változóra hivatkozik:
int& rosszFuggveny() {
int szam = 100;
return szam; // HIBA! Lokális változóra mutató referencia visszaadása
}
Ez nem működik, mert a szam változó megsemmisül, amikor a függvény befejeződik.
Referenciát osztályokon belül is használhatunk adattagként:
class Auto {
private:
int& sebesseg;
public:
Auto(int& seb) : sebesseg(seb) {}
void gyorsit() { sebesseg += 10; }
};
int main() {
int seb = 60;
Auto a(seb);
a.gyorsit();
cout << "Sebesség: " << seb << endl; // 70 lesz
return 0;
}
Itt az Auto osztály egy referenciát tárol a seb változóra, így bármilyen módosítás visszahat az eredeti változóra is.
Fontos: Az osztály adattagjaként lévő referenciát kötelező inicializálni a konstruktornál.
const referencia biztosítja, hogy a függvény nem módosíthatja a paramétert.