Az előbb az RAII elv alapján az erőforráskezelés
problémáját az std::vector<> osztályra toltuk ki.
Nézzük meg egy kicsit a problémakört ennek az osztálynak a szemszögéből:
egy egyszerű dinamikus tömb sablonosztályon keresztül.
template <typename T>
class Vektor {
private:
T *adat;
size_t meret;
public:
explicit Vektor(size_t s = 0) {
meret = s;
adat = new T[s];
}
~Vektor();
Vektor(Vektor const & masolando);
Vektor & operator=(Vektor const & masolando);
};
A konstruktorban már látszik, hogy ez az osztály egy dinamikusan foglalt
tömbért felel, emiatt tudjuk, hogy a destruktor így kell kinézzen:
template <typename T>
Vektor<T>::~Vektor() {
delete[] adat;
}
A destruktorról egyből eszünkbe jut az ökölszabály is, miszerint ha egy osztálynak
a destruktor, másoló konstruktor, értékadó operátor közül bármelyik kell,
akkor szinte biztos, hogy mind a három kell. Gyorsan egy
másoló konstruktort:
template <typename T>
Vektor<T>::Vektor(Vektor<T> const & masolando) { // rossz
meret = masolando.meret;
adat = new T[meret];
for (size_t i = 0; i < meret; ++i)
adat[i] = masolando.adat[i];
}
Az előző részben leírtakból okulva itt azonban egyből be is ránthatjuk
a kéziféket. A helyzet ugyanis: ebben a pársoros függvényben egy csomó
helyen keletkezhet kivétel. Némelyek olyanok, amelyekről nem is tudunk
semmit, mivel a T típus a sablon kódban ismeretlen számunkra!
- A
new T[meret] kifejezés hatására először lefoglalódik
meret darab T-nek elegendő memóriaterület.
Ha ez a foglalás nem sikerül, akkor egy std::bad_alloc
kivétel dobódik.
- Gond ez nekünk? Igen, mert nem tud létrejönni a vektor. De
a kivételt szándékosan nem kapjuk el, mert a konstruktorból csak
így tudjuk jelezni a hibát.
- Ezek után lefut
meret darab T() alapértelmezett
konstruktor. Ezek közül bármelyik dobhat kivételt.
- Vajon ez gond? Fogasabb kérdés, hiszen a dinamikus memóriaterület
már le van foglalva, sőt az objektumok egy része inicializálva van, a másik
részük pedig még memóriaszemét. De ezt a kivételt sem szabad elkapnunk: a fordító
biztosítja számunkra, hogy tömb foglalásakor a már inicializált elemek
destruktora lefut, és a dinamikus memóriaterület automatikusan felszabadul.
(Ez csakis erre az esetre igaz! Máskor a tömb nem szabadul
fel magától.)
- Végül jönnek a másolások. A
T osztály operator=
értékadó operátora fog lefutni meret-szer. Ezek közül
bármelyik kivételt dobhat. Mivel ilyenkorra a tömb foglalása megtörtént,
ezért ezen a ponton a tömbért már mi felelünk!
Tehát az utóbbi esetet kezelnünk kell. Mivel itt most nem szeretnénk egy
std::vector-t használni (épp azt hivatott bemutatni az írás, hogy
annak a belsejében mi történik), kénytelenek vagyunk elkapni ezt a kivételt,
és a tömb felszabadítását „kézzel” elvégezni:
template <typename T>
Vektor<T>::Vektor(Vektor<T> const & masolando) {
meret = masolando.meret;
adat = new T[meret];
try {
for (size_t i = 0; i < meret; ++i)
adat[i] = masolando.adat[i];
} catch (...) {
delete[] adat;
throw;
}
}
Így már nem fog memóriaszivárgást okozni az, ha a Vektor objektumot nem
lehet létrehozni. A hívó pedig, aki megpróbálta a másoló konstruktorát lefuttatni,
kivételt fog kapni.
A new T[meret] rész nem került bele a try{} blokkba,
mivel annak memóriaszivárgás-mentességét a fentiek szerint a fordító biztosította.
Nem is lenne szabad beletennünk! Ha az is a try{} blokkban lenne,
akkor elkapnánk azt a kivételt is, amely a new-tól származik. Ez
a kivétel azonban az adat pointer értékadása előtt keletkezik, tehát
a catch{} blokkba úgy kerülnénk, hogy az adat pointer
még memóriaszemét. A delete[]-en pedig ilyenkor elhasalna a program.
Nézzük végül az értékadó operátort. Tudjuk, hogy az
összeollózható a destruktorból és a másoló konstruktorból, de nézzük nagyon
kritikusan az eredményt:
template <typename T>
Vektor<T> & Vektor<T>::operator=(Vektor<T> const & masolando) { // rossz
if (this != &masolando) {
delete[] adat;
meret = masolando.meret;
adat = new T[meret];
try {
for (size_t i = 0; i < meret; ++i)
adat[i] = masolando.adat[i];
} catch (...) {
delete[] adat;
throw;
}
}
return *this;
}
Bár a kivételbiztos másoló konstruktort másoltuk be ide, rá kell
jönnünk, hogy ez így egyáltalán nem lesz jó. Ugyanis bármelyik helyen
dobódik kivétel, akár a new-nál, akár a
for() ciklusban, meg vagyunk lőve: a régi tömböt, a
régi T-ket már felszabadítottuk, az újakat
pedig nem tudjuk létrehozni! Ilyenkor a régi T-k
felszabadítását már nem tudjuk visszacsinálni. A Vektor használója pedig
hiába teszi az értékadást try-catch blokkba:
Vektor<std::string> v1 = ....., v2 = .....;
try {
v1 = v2;
} catch (...) {
std::cerr << "Nem sikerült az értékadás.\n";
}
std::cerr << "De most itt mi van az v1-ben?!?!\n";
Addig ugyan rendben, hogy ő értesül a hibáról, és tudja, hogy az
értékadás nem sikerült. De mi lesz ezután a v1
objektumával? Az az objektum ilyenkor érvénytelen, félholt
állapotban van: nincsen dinamikus tömbje. A v1.adat
pointer memóriaszemét. Még ha nem is használja ezt az v1
objektumot semmire a hívó, akkor is előbb-utóbb le kell futnia a
destruktorának, amely pedig azt várja, hogy értelmes adatot lásson
a pointerben.
Ez megengedhetetlen. A legjobb megoldás az lenne, ha el lehetne
valahogyan érni azt, hogy az értékadás atomi, bonthatatlan legyen.
Azaz vagy történjen meg teljes egészében, hibátlanul, vagy pedig dobódjon
kivétel, de akkor az objektum maradjon „sértetlen”, sőt lehetőleg
tartsa is meg az eredetileg tárolt adatokat. Ezt úgy tudjuk megoldani,
ha a destruktorból és a másoló konstruktorból összeollózott részeket
megcseréljük, vagyis előbb végezzük el a kritikus lépéseket,
tehát a másolást, és csak utána a felszabadítást. Valahogy így:
template <typename T>
Vektor<T> & Vektor<T>::operator=(Vektor<T> const & masolando) { // jó (jó bonyolult)
if (this != &masolando) {
size_t ujmeret = masolando.meret;
T * ujadat = new T[ujmeret];
try {
for (size_t i = 0; i < ujmeret; ++i)
ujadat[i] = masolando.adat[i];
} catch (...) {
delete[] ujadat;
throw;
}
delete[] adat;
adat = ujadat;
meret = ujmeret;
}
return *this;
}
Nézzük meg, ez helyes-e. Ha a new T[] kifejezés dob,
azt nem kell elkapnunk. A hívó megkapja, és tudja, hogy az értékadás sikertelen.
Se a meret, se az adat adattaghoz nem nyúltunk, így
az objektum változatlanul maradt. Ezután jön a T-k másolása.
Ha valamelyik T::operator= dob, elkapjuk, felszabadítjuk az
elkezdett másolat tömböt, és továbbdobjuk a kivételt. A hívó értesül, a
vektor továbbra is érvényes és változatlan.
Ha ezek is mind sikerültek, készen áll a másolat. Innentől jön a régi
adatok törlése: a delete[] adat. Dobhat ez kivételt?
Nem! A szabvány megköveteli, hogy a destruktorok ne dobjanak
kivételt, és ha a T osztályt szabványkövető módon írták meg,
akkor az sem dob. (Amúgy is, miért dobna, a memória felszabadítása
egyszerű művelet, a foglalás a necces.) Végül két értékadással fejezzük be, amelyek közül az
egyik egy egész számot, a másik pedig egy pointert másol. Ezek közben
sem keletkezhet kivétel, a világ legegyszerűbb műveletei.
