Ugrás a tartalomhoz

call by const reference

A Wikiszótárból, a nyitott szótárból
(pass by const reference szócikkből átirányítva)

Angol


Főnév

call by const reference (tsz. call by const references)

  1. (informatika) A C++ programozási nyelvben a függvények bemeneti adatok feldolgozására szolgálnak. Amikor egy függvényhívás során adatot adunk át, fontos, hogy ezt hatékonyan, az adott célhoz legmegfelelőbb módon tegyük meg.

A paraméterátadásnak több módja van:

  • Érték szerint (call by value): másolat készül a bemeneti értékről
  • Referencia szerint (call by reference): a változó eredeti példányát adja át a függvény
  • Pointerrel (call by pointer): a változó címét adja át a függvény
  • Konstans referencia szerint (call by const reference) – mai témánk

Mi az a call by const reference?

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.

  • A const int& x paraméter azt jelzi:
    • a x referencia (nem másolat),
    • de konstans: a x értéke nem változtatható meg a függvényen belül.

Miért hasznos a konstans referencia?

1️⃣ Másolatkészítés elkerülése

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:

  • időigényes
  • memóriaigényes

A konstans referencia használatával nem készül másolat, csak egy referencia kerül átadásra, így:

✅ gyors ✅ hatékony

2️⃣ Védelem a módosítástól

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:

  • a függvényhívó fél biztos lehet abban, hogy a változója nem változik meg.

Hogyan deklaráljunk const reference paramétert?

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);

Milyen típusoknál ajánlott?

Kis típusok (int, char, double, bool)

  • Nem érdemes const reference-et használni.
  • Ezek másolása olcsó → jobb, ha by value adjuk át.
void printInt(int x); // jobb, mint const int&

Nagy típusok (std::string, std::vector, std::map, std::set, osztálypéldányok)

  • Mindig ajánlott const reference-et használni.
  • Elkerüljük a drága másolást.
void processData(const std::vector<double>& data);
void printStudent(const Student& student);

Hogyan működik a háttérben?

Amikor const reference-et adunk át:

  1. A függvény egy referenciát kap a tényleges változóra.
  2. Nincs másolat.
  3. A referencia csak olvasható (const miatt).
  4. Az eredeti változó élettartamának érvényesnek kell lennie a függvényhívás során.

Példák

Példa 1 – std::string

void greet(const std::string& name) {
    std::cout << "Hello, " << name << "!" << std::endl;
}

int main() {
    std::string myName = "Alice";
    greet(myName); // NINCS másolat, gyors
}

Példa 2 – std::vector

void printVector(const std::vector<int>& v) {
    for (auto x : v) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
}

Példa 3 – saját osztály

class Student {
public:
    std::string name;
    int age;
};

void printStudent(const Student& s) {
    std::cout << s.name << ", " << s.age << " years old" << std::endl;
}

Összehasonlítás más paraméterátadásokkal

Á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

Előnyök

✅ 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

Hátrányok / figyelmeztetések

⚠️ 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
}

Mikor érdemes const reference-et használni?

✅ 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.

Best practice

  • Minden nagy típusú paramétert, amelyet nem kell módosítani, adj át const reference-ként.
  • Kis típusokat adj át by value.
  • Írj világos dokumentációt (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);

Összefoglalás

A call by const reference az egyik leghasznosabb eszköz a C++ paraméterátadás világában.

  • Nagy méretű objektumokat másolás nélkül adhatunk át.
  • A függvényen belül nem módosíthatjuk az eredeti változót.
  • Segít hatékony, biztonságos és könnyen olvasható kódot írni.

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.


További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=call_by_const_reference&oldid=3500189”