call by const reference (tsz. call by const references)
A paraméterátadásnak több módja van:
A const reference kifejezés a következőt jelenti:
👉 Egy függvény paraméterként referenciát kap egy változóra, de nem módosíthatja azt, mert a referencia const (konstans).
Egyszerű példa:
void printValue(const int& x) {
std::cout << x << std::endl;
}
Ebben az esetben a printValue függvény egy int típusú érték konstans referenciáját kapja.
const int& x paraméter azt jelzi:
x referencia (nem másolat),x értéke nem változtatható meg a függvényen belül.
Ha érték szerint adnánk át egy nagy objektumot (pl. std::vector, std::string, saját osztály példány), a C++ minden egyes függvényhíváskor lemásolná az objektumot.
Ez:
A konstans referencia használatával nem készül másolat, csak egy referencia kerül átadásra, így:
✅ gyors ✅ hatékony
Ha egyszerű referenciát adnánk át (Type& x), a függvény megváltoztathatná az eredeti objektumot.
Ha nem akarjuk, hogy a függvény megváltoztassa az értéket, a const kulcsszóval jelezhetjük ezt:
void foo(const std::string& s) {
// s = "hello"; // HIBA: s konstans
std::cout << s << std::endl;
}
Itt a foo függvény csak olvashatja s-t, de nem módosíthatja.
Ez nagy biztonságot ad:
Szintaxis:
void functionName(const Type& parameterName);
Példák:
void printVector(const std::vector<int>& v);
void displayName(const std::string& name);
void printStudent(const Student& s);
const reference-et használni.void printInt(int x); // jobb, mint const int&
const reference-et használni.void processData(const std::vector<double>& data);
void printStudent(const Student& student);
Amikor const reference-et adunk át:
void greet(const std::string& name) {
std::cout << "Hello, " << name << "!" << std::endl;
}
int main() {
std::string myName = "Alice";
greet(myName); // NINCS másolat, gyors
}
void printVector(const std::vector<int>& v) {
for (auto x : v) {
std::cout << x << " ";
}
std::cout << std::endl;
}
class Student {
public:
std::string name;
int age;
};
void printStudent(const Student& s) {
std::cout << s.name << ", " << s.age << " years old" << std::endl;
}
| Átadás módja | Másolat készül? | Módosítható? |
|---|---|---|
| Call by value | Igen | Csak másolat |
| Call by reference | Nem | Igen |
| Call by const ref | Nem | Nem |
| Call by pointer | Nem (címet ad át) | Igen |
✅ Nagy objektumok hatékony átadása ✅ Garantált, hogy a függvény nem változtatja meg az eredeti objektumot ✅ Megkönnyíti az optimalizációt → gyorsabb kód ✅ Jobb dokumentáció, kódolvasás → a const világosan jelez szándékot
⚠️ Kis típusoknál felesleges → jobb by value használni ⚠️ Ne feledd: a referencia csak akkor érvényes, ha a változó létezik a függvényhívás teljes ideje alatt.
Példa, ami hibás lenne:
const std::string& getName() {
std::string name = "Bob";
return name; // HIBA! A "name" lokális változó → élettartama megszűnik
}
Helyesen:
std::string getName() {
std::string name = "Bob";
return name; // OK → RVO (Return Value Optimization) segít
}
✅ Nagy méretű típusok esetén → std::vector, std::map, std::set, std::string, saját osztályok ✅ Ha a függvény csak olvasni akarja az adatot ✅ Ha el akarod kerülni a felesleges másolatkészítést
Nem érdemes: int, double, char, bool, short, float, long → by value hatékonyabb.
const reference-ként.const → garantálja a nem-módosítást).Példa függvénydeklaráció jó stílusban:
void processData(const std::vector<double>& data);
void displayText(const std::string& text);
void printReport(const Report& report);
A call by const reference az egyik leghasznosabb eszköz a C++ paraméterátadás világában.
A C++ modern stílusú kódban (pl. STL, algoritmusok, könyvtári függvények) széles körben használják. Ha C++-ban komolyabb programot írsz, a const reference az egyik legfontosabb alapfogalom, amit jól kell értened és következetesen kell alkalmaznod.