Ugrás a tartalomhoz

copy assignment operator

A Wikiszótárból, a nyitott szótárból

Angol


Főnév

copy assignment operator (tsz. copy assignment operators)

  1. (informatika) A másoló értékadó operátor (angolul: copy assignment operator) a C++ nyelv egyik alapvető objektum-orientált eszköze, amely lehetővé teszi, hogy egy már létező objektumnak másik objektum értékét másoljuk át. Ez különbözik a másoló konstruktortól, amely új objektum példányosításakor másol.


🧱 Alapdefiníció

A másoló értékadó operátor szintaxisa:

ClassName& operator=(const ClassName& other);

Ez a művelet akkor hajtódik végre, amikor már létező objektumra értékül adunk egy másikat:

Szamok a(10, 1.0);
Szamok b(5, 2.0);

b = a;  // ← itt hívódik meg a másoló értékadó operátor

📍 Alapértelmezett viselkedés

Ha nem definiálod, a fordító automatikusan létrehoz egy shallow copy-t végző másoló operátort. Ez azt jelenti, hogy a tagváltozók értékeit egyszerűen átmásolja, akkor is, ha az egyik pointer. Ez veszélyes lehet dinamikus memóriakezelés esetén:

class Szamok {
    double* tomb;
    unsigned meret;
    // ...
};

Ebben az esetben a tomb tömb pointerként másolódik, tehát két objektum ugyanarra a memóriaterületre mutat, ami duplikált delete[] hívásokhoz vezethet (undefined behavior). Ezért ha van dinamikus memória, saját másoló operátort kell írni!


⚠️ Példa probléma, ha NEM írsz saját operátort

Szamok a(5, 3.14);
Szamok b(5, 2.71);

b = a;  // automatikus shallow copy

// Mindkettő ugyanazt a tomb memóriát használja

Amikor b destruktora meghívódik, felszabadítja a tomb tömböt. Ezután a destruktora szintén megpróbálja felszabadítani ugyanazt, és itt jön a hiba: double delete.


✅ Helyes másoló értékadó operátor – mély másolat (deep copy)

A helyes implementáció így néz ki:

Szamok& Szamok::operator=(const Szamok& other) {
    if (this != &other) {  // Ön-hozzárendelés ellenőrzése
        delete[] tomb;     // Saját memória felszabadítása
        meret = other.meret;
        tomb = new double[meret];  // Új memória foglalása
        for (unsigned i = 0; i < meret; ++i) {
            tomb[i] = other.tomb[i];  // Érték másolás
        }
    }
    return *this;
}

Részletezés:

  • this != &other → megelőzi az ön-hozzárendelést (a = a;).
  • delete[] tomb → felszabadítja a régi tömböt.
  • new double[meret] → új helyet foglal.
  • tomb[i] = other.tomb[i] → érték másolás történik, nem pointer.


🧪 Példa osztály beépített másoló operátorral:

class Szamok {
    unsigned meret;
    double* tomb;
public:
    Szamok(unsigned meret, double ertek = 0.0) : meret(meret) {
        tomb = new double[meret];
        for (unsigned i = 0; i < meret; ++i) {
            tomb[i] = ertek;
        }
    }

    ~Szamok() {
        delete[] tomb;
    }

    // Másoló konstruktor
    Szamok(const Szamok& other) : meret(other.meret) {
        tomb = new double[meret];
        for (unsigned i = 0; i < meret; ++i) {
            tomb[i] = other.tomb[i];
        }
    }

    // Másoló értékadó operátor
    Szamok& operator=(const Szamok& other) {
        if (this != &other) {
            delete[] tomb;
            meret = other.meret;
            tomb = new double[meret];
            for (unsigned i = 0; i < meret; ++i) {
                tomb[i] = other.tomb[i];
            }
        }
        return *this;
    }
};

🛡 “Rule of Three”

Ha egy osztály:

  • saját destruktort ír,
  • saját másoló konstruktort ír,
  • akkor írnia kell másoló értékadó operátort is.

Ez a “Rule of Three”. Modern C++-ban már létezik a “Rule of Five” is, amelyhez a move constructor és move assignment is tartozik.


♻️ Move assignment vs Copy assignment

  • Copy assignment (operator=const&): érték másolása (új példányt csinál)
  • Move assignment (operator=&&): erőforrások átvétele (hatékonyabb, lásd std::move)


📌 További megjegyzések

  • Ha a példány tartalmaz std::vector, std::string, vagy más RAII-t használó típust, akkor nem szükséges saját másoló értékadó operátort írni.
  • Ha biztos akarsz lenni benne, hogy senki ne másolja az objektumot, akkor operator= törölhető:
Szamok& operator=(const Szamok&) = delete;

🧠 Összegzés

A másoló értékadó operátor:

  • Akkor fut le, amikor egy meglévő objektumra értékül adunk egy másikat.
  • Saját memóriakezelés esetén kötelező a megfelelő implementáció.
  • Az ön-hozzárendelés ellenőrzése kulcsfontosságú.
  • A destruktor, másoló konstruktor és másoló operátor hármasa együtt biztosítja a helyes működést (Rule of Three).
  • Elengedhetetlen része a robusztus, hibamentes osztálytervezésnek.


További információk

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