clone correctness

Angol

Főnév

clone correctness (tsz. clone correctnesses)

(informatika) Az objektumorientált programozás (OOP) egyik alapvető fogalma a példányosítás: példányokat hozunk létre osztályokból. Gyakran előfordul, hogy egy meglévő objektum másolatát szeretnénk készíteni — egy új példányt, amely az eredetivel azonos állapotot tartalmaz, de független attól.

Ezt a feladatot szolgálja a clone() nevű tagfüggvény, amely sok osztályhierarchiában megjelenik. A clone correctness (magyarul: helyes klónozás) azt jelenti, hogy a clone() metódust úgy kell megvalósítani, hogy a másolat:

✅ helyes legyen (az objektum állapota teljeskörűen másolódik), ✅ független legyen az eredetitől (ne mutasson az eredeti belső adataira), ✅ polimorfikusan működjön (öröklődő hierarchiában is), ✅ ne okozzon memóriakezelési hibát (ne szivárogjon memória, ne keletkezzen duplikált felszabadítás, stb.).

Miért kell `clone()`?

Miért nem elég a másoló konstruktor (copy constructor)?

A másoló konstruktor akkor működik, ha a tényleges típus ismert (például ha van egy Auto típusú objektumod és Auto a2(a1); hívást csinálsz).
De ha polimorfikusan szeretnéd kezelni az objektumokat — például ha Jarmu* típusú mutatókban tárolod őket, és nem tudod előre, hogy a mutató Auto-ra vagy Motor-ra mutat — akkor a másoló konstruktor nem használható közvetlenül.
Ilyenkor a clone() metódus egy polimorfikus (virtuális) függvény, amely a dinamikus típusnak megfelelő új példányt állít elő.

Példa:

Jarmu* j = new Auto("Ford");
Jarmu* j2 = j->clone();  // j2 is Auto*, de típusa Jarmu* - polimorfikus másolat

A clone correctness jelentése

A helyes klónozás során a következő szabályokat kell betartani:

1. Új példányt kell visszaadni

A clone() nem térhet vissza az eredeti példányra (pl. return this; → helytelen).

Helyes:

return new Auto(*this);

2. Teljes, mély másolatot kell készíteni

Az objektum minden állapotát (attribútumát) másolni kell:

Ha az attribútum beágyazott objektum vagy mutató, akkor új példányt kell belőle létrehozni (deep copy).
Ha csak primitív típus vagy std::string vagy std::vector, akkor a másoló konstruktor elég.

Példa hibás klónozásra:

// Hiba: csak a pointert másolja, nem az objektumot!
this->ptr = other.ptr;

Helyes:

// Mély másolat:
this->ptr = new Valami(*other.ptr);

3. Polimorfikus működés

A clone() metódust virtuálisként kell deklarálni a bázisosztályban:

class Jarmu {
public:
    virtual ~Jarmu() {}
    virtual Jarmu* clone() const = 0;
};

A származtatott osztályokban felül kell írni:

class Auto : public Jarmu {
public:
    virtual Auto* clone() const override {
        return new Auto(*this);
    }
};

Miért fontos ez? Mert így a következő kód működik helyesen:

Jarmu* j = new Auto("BMW");
Jarmu* j2 = j->clone();  // Automatikusan Auto típusú objektum készül

Ha nem lenne virtual, a bázisosztályból hívott clone() mindig csak bázisosztály-objektumot adna vissza.

4. Memóriakezelés helyessége

A clone() függvény során dinamikus memóriát allokálunk (pl. new Auto). Emiatt fontos:

A másolatért felelős legyen, aki létrehozta (→ később delete).
A destruktor legyen virtuális, hogy delete során a megfelelő destruktor fusson le.

Példa:

Jarmu* j2 = j->clone();
delete j2;  // Biztosan lefut az Auto destruktora, ha az volt a dinamikus típus

Ha nem lenne virtual ~Jarmu(), akkor csak a Jarmu destruktora futna le, ami memória-szivárgást okozhat.

Mikor beszélünk hibás klónozásról (clone incorrectness)?

Ha clone() nem új példányt ad vissza → aliasing bug.
Ha nem másol minden belső adatot → hiányos példány.
Ha pointereket shallow copy-val másol → két objektum ugyanarra a belső adatra mutat.
Ha nem polimorf → helytelen típusú objektum keletkezik.
Ha memóriaszivárgást okoz → destruktorban nincs megfelelő delete.

Példa: helyes klónozás komplex példában

class Jarmu {
public:
    virtual ~Jarmu() {}
    virtual Jarmu* clone() const = 0;
};

class Auto : public Jarmu {
    std::string marka;
    int evjarat;
    int* kmAllas;
public:
    Auto(const std::string& m, int e, int km)
        : marka(m), evjarat(e), kmAllas(new int(km)) {}

    Auto(const Auto& other)
        : marka(other.marka), evjarat(other.evjarat), kmAllas(new int(*other.kmAllas)) {}

    Auto& operator=(const Auto& other) {
        if (this != &other) {
            marka = other.marka;
            evjarat = other.evjarat;
            delete kmAllas;
            kmAllas = new int(*other.kmAllas);
        }
        return *this;
    }

    virtual Auto* clone() const override {
        return new Auto(*this);
    }

    virtual ~Auto() {
        delete kmAllas;
    }
};

A konstruktor, másoló konstruktor, operátor, destruktor → együtt garantálják a helyes működést.
A clone() pontosan azt csinálja, amit kell: új példányt készít, mély másolattal.

Gyakori hibák

A clone() implementáció nem mély másolatot készít → ha az eredeti objektum törlődik, a másolat hibás lesz.
A clone() nem polimorfikus → nem a valódi dinamikus típust másolja.
A clone() nem ad vissza új példányt → return this; (óriási hiba).
A clone() elfelejt allokálni dinamikusan → stack objektumot próbál visszaadni → UB (undefined behavior).