dynamisches Array als Rückgabewert

Question

Hallo zusammen,

als C++ Neuling hätte ich folgende Frage an euch: wird der dynamisch allozierte Speicher in folgendem Beispiel korrekt wieder freigegeben? Also sprich: "weiß" Zeiger pm, dass er 10 int-Werte betreut, die freizugeben sind?

Wenn ja, wie "macht" der Zeiger das intern? Das muß dann ja irgendwie mehr als nur eine Adresse sein?

int* test() {
	int* p = new int[10];
	return p;
}

int main() {
	int* pm = test();
	delete[] pm;
}

Gruß Joerg

Answer 1

Hallo,

hier ist die Antwort: https://stackoverflow.com/questions/197675/how-does-delete-know-the-size-of-the-operand-array

Der Zeiger "weiß" das nicht, aber der heap weiß es. Dein Speicher wird also komplett freigegeben.

Gruß Guido

Answer 2

um ehrlich zu sein, frage ich mich immer wieder, wie ein Betriebssystem das schafft, mitunter zig-mal pro Sekunde verschiedenste Speicherblöcke zu allokieren und wieder freizugeben.

Der im Link beschriebene Ansatz ist meiner (bescheidenen) Meinung nach ja auch nur die halbe Wahrheit. Der Compiler kann sich schön die Größe des angeforderten Speicherblocks in ein paar Zusatzbytes merken, aber das Betriebssystem (der "malloc" Befehl) muss sich ja irgendwo merken, wo überhaupt belegte Speicherblöcke herumliegen. Das wäre ja auch noch mit einer Liste von Zeigern einfach zu bewerkstelligen. Jetzt werden aber viele Blöcke wieder freigegeben und der Hauptspeicher sieht aus wie Schweizer Käse. .. wie weiß man, wo überhaupt ein neuer Block wieder Platz hat?

Das führt mich unweigerlich zu einer weiteren Frage:

Angenommen ich habe ein mehrdimensionales Datenfeld double DATA[x][y][z], das ich dynamisch anlegen will. Unter C++ könnte man es folgendermaßen machen:

double ***pData = new double **[NUM_X];
for (int x = 0; x < NUM_X; x++) {
   pData[x] = new double *[NUM_Y];
   for (int y = 0; y < NUM_Y; y++) {
      pData[x][y] = new double [NUM_Z];
      for (int z = 0; z < NUM_Z; z++) pData[x][y][z] = 0.0;
   }
}

...
use array
...

Nun heißt das aber - bei genauem Hinsehen - dass NUM_X*NUM_Y Speicherblöcke mit jeweils sizeof(double)*NUM_Z Bytes vom Betriebssystem angefordert werden. Ich gehe davon aus, dass das OS die Speicherblöcke quantisiert, um sie irgendwie verwalten zu können. Das heißt, dass mitunter wesentlich mehr Hauptspeicher belegt sein wird, als die Milchmädchenrechnung NUM_X*NUM_Y*NUM_Y*sizeof(double).

Wenn ich noch mehr Dimensionen im Einsatz habe, mache ich es daher mitunter so, dass ich EINEN großen Datenblock anlege:

int IDX(int x,int y,int z) {
   return(x*NUM_Y*NUM_Z + Y*NUM_Z + Z);
}

void foo() {
  double *pDATA = new double [NUM_X*NUM_Y*NUM_Z];

  a = pDATA[IDX(x,y,z)];
  

  delete [] pDATA;
}

Was meint ihr dazu?

FireHeart