Ha a fent említett dolgok közül valamelyiket meg kellene írnod, akkor muszáj vagy megírni a többit is, hogy a kódod jól működjön hiszen általában azért kell neked a destruktor, hogy az esetlegesen lefoglalt memóriát felszabadítsd, akkor viszont az = operátort is meg kell írnod, hisz a régi tartalmat meg kell semmisítened, mielőtt berakod az újat.
Én Code::Blocks-ot használok a komolyabb C++ projektjeimhez, amelyben lehetőség van arra, hogy azonnal beszúrjunk egy templátot az új osztályainkhoz. Én javaslom azt, hogy ha új osztályt kezdünk, akkor az így nézzen ki:
class OsztályNév
{
public:
~OsztályNév() {}
OsztályNév* &operator=(const OsztályNév &from);
OsztályNév(const OsztályNév &from);
protected:
private:
}
A destruktor alapértelmezésben üres, azt ki kell fejteni, mert különben a program nem lesz hajlandó lefordulni, azonban a másoló konstruktor, és az = operátor nincs kifejtve, mert általában csak az objektumokra mutató referenciát passzolgatjuk. Azonban az első adandó alkalommal, amikor ténylegesen másolni szeretnénk, a program nem fog lefordulni figyelmeztetve minket arra, hogy meg kellene írnunk a szükséges metódusokat.
Na most célszerű lenne tudni, hogy ez a 3 mit is csinál:
- Destruktor: az objektum megsemmisülése előtti teendőket hajtja végre (pl.: erőforrások felszabadítása).
- Másoló konstruktor: lefoglaljuk az objektum működéséhez szükséges erőforrásokat, majd az objektumunkat egy másik példány másolataként hozzuk létre.
- = operátor: megsemmisítjük az objektumot, majd létrehozzuk az újat, egy meglévő példány alapján.
- Alapértelmezett konstruktor: lefoglalja az objektum működéséhez szükséges erőforrásokat, és alaphelyzetbe állít mindent.
Három fő dolog figyelhető meg: erőforrások lefoglalása, másolat létrehozása egy meglévő példányból illetve az erőforrások felszabadítása. Erre a három dologra rögtön érdemes 3 privát metódust írni.
- _construct: az erőforráslefoglaláshoz
- _constructFrom: a másik objektumból való létrehozáshoz
- _destruct: a megsemmisítés
Így ha meg kell írnunk a másolást végző részeket, akkor a kódunk így módosul:
class OsztályNév
{
public:
OsztályNév()
{
_construct();
}
~OsztályNév()
{
_destruct();
}
OsztályNév* &operator=(const OsztályNév &from)
{
if (this==&from) return *this;
_destruct();
_constructFrom(from);
return *this;
}
OsztályNév(const OsztályNév &from)
{
_constructFrom(from);
}
protected:
private:
void _construct() {}
void _destruct() {}
void _constructFrom(const OsztalyNec &from)
{
_construct();
}
}
És csak a _construct(), _destruct() és _constructFrom metódusokba írjunk, a többi adott. Még egy fontos dolog, hogy az = operátorban és bármikor, amikor értékadás operátort írunk felül, kezeljük azt az esetet, hogy ha önértékadás van, mert ha megsemmisítjük magunkat, aztán magunk alatt akarunk objektumot létrehozni, akkor abból sok gond lehet.
