Foglaljunk tömböket most! A következő forráskód a new és a delete helyett a beépített
new[] és a delete[] operátorokat írja felül. Aztán pedig foglal és felszabadít tömböket,
méghozzá 1) beépített típusú, 2) objektum és 3) destruktorral rendelkező objektum típusú elemekből:
#include <iostream>
void * operator new[] (size_t s) {
void *p = malloc(s);
std::cout << "Allocated " << s << " bytes at " << p << std::endl;
return p;
}
void operator delete[] (void *p) noexcept {
std::cout << "Freed block at " << p << std::endl;
free(p);
}
void operator delete[] (void *p, size_t s) noexcept {
std::cout << "Freed " << s << " bytes at " << p << std::endl;
free(p);
}
class A { // nincs destruktor (triviális)
public:
int i;
};
class B { // van destruktor
public:
int i;
~B() { std::cout << "."; }
};
int main() {
int *pi = new int[11]; // 1
delete[] pi;
A *pa = new A[11]; // 2
delete[] pa;
B *pb = new B[11]; // 3
delete[] pb;
}Allocated 44 bytes at 0x55a096b4ae70 1 Freed block at 0x55a096b4ae70 Allocated 44 bytes at 0x55a096b4ae70 2 Freed block at 0x55a096b4ae70 Allocated 52 bytes at 0x55a096b4b2b0 3 ..........Freed 52 bytes at 0x55a096b4b2b0
Mi történik az egyes esetekben?
- Az első esetben 11
int-et foglalunk le. A foglaláskor ugyan ismert a méret, a felszabadításkor viszont nem, mert nem tudni, hogy a pointer „mögött” mekkora tömb van. - Ugyanez a helyzet a második esetben, az
Atípusú objektumok foglalásakor. A lefoglalt terület amúgy ugyanakkora, mint az előbb, mert az objektumban csak egyintadattag van. - Ettől eltér viszont a harmadik eset, a
Bobjektumok tömbje. A lefoglalt terület mérete nagyobb valamiért (44 helyett 52 bájt), és a felszabadítás is megkapja a foglalt terület méretét.
A különbséget a destruktor megjelenése okozza. Mivel a B osztálynak van destruktora,
a fordítónak fel kell készülnie a tömb felszabadítására. A foglaláskor, vagyis a new B[11] végrehajtásakort
feljegyzi a tömb méretét a tömb elé. Ezért lett nagyobb a memóriaterület: 44 bájt kell a 11 darab
B objektumnak, és még 8 bájt egy size_t-nek, ahova az elemszámot teszi. Ezt pedig felszabadításkor
kiolvassa, hogy meg tudja hívni a 11 destruktort. Ha pedig a tömb elemszáma ismert, abból a tömb mérete könnyedén
kiszámítható újra, és akkor már hívható akár az operator delete[](void *, size_t) függvény is.
Vagyis ha nincs destruktora az osztálynak, akkor a lefoglalt területen csak az objektumok vannak:
Ha van destruktor, akkor pedig egy kicsit nagyobb memóriaterületet kell foglalni, mert fel kell jegyezni az objektumok számát is. A hívás eredménye természetesen ilyenkor is a tömb elején lévő objektumra mutat:
