ich habe eine Struktur

typedef struct planeten_TYP
{	
	int	anzahl;
	char	typ[500];
} struck_planeten;

am Anfang reservier ich mir 1x die Sruktur

struck_planeten     *planeten;
planeten=new struck_planeten[1];
planeten[0].anzahl = 1;

Im Programm dann, möchte ich in einer Schleife noch mehr reservieren

int i=0;
while (i<5000) //5000 ist ein Beispiel, es können beliebig viele sein
{
  struck_planeten *tmp_obj = new struck_planeten[planeten[0].anzahl+1];
  int anzahl_merker = planeten[0].anzahl+1;
  for(unsigned int i2 = 0; i2 < planeten[0].anzahl; ++i2)
  {
	tmp_obj[i2] = planeten[i2]; 
  }
  planeten = NULL;
  delete [] planeten;
  planeten = new struck_planeten[anzahl_merker];
  for(i2 = 0; i2 < anzahl_merker; ++i2)
  {
	planeten[i2] = tmp_obj[i2];
  }
  tmp_obj = NULL;
  delete [] tmp_obj;
  planeten[0].anzahl = anzahl_merker;
  i++;
}

aber genau in dieser Schleife läuft das Prog Amok und reserviert so viel Speicher, bis der Rechner keinen mehr hat. Bei mir ist es bei 2,1GB angeknallt, was ca 4300x die Struktur war.

Irgendwo ist mein Denkfehler.

Normal müsste 1x reservieren 504 byte belegen, bei mir sind es aber 504 KB.
Das ganze dann mal 5000 = 2,4 GB an Speicher anstatt 2,4 MB.

...
[c++]
...
planeten = NULL;
delete [] planeten;
planeten = new struck_planeten[anzahl_merker];
...
[/c++]
...

Hier wird kein Speicher freigegeben. Musst die ersten beiden Zeilen vertauschen, dann sollte es funktionieren.

liegt es evtl daran?

NACH dem löschen kannst du den Pointer auf NULL setzen, zur Sicherheit.

dann ist aber auch schon wieder etwas schiefgelaufen, wenn ein zeiger zweimal deleted wird. deshalb sollte man einen zeiger nicht auf 0 setzen, damit soetwas entdeckt wird.

btw gibt es "NULL" in c++ eigentlich nicht.

mfg

btw gibt es "NULL" in c++ eigentlich nicht.

aber eigentlich doch

aber eigentlich doch

wenn man sich ein makro baut:

Die C++ Programmiersprache, Seite 96 schrieb:

In C war es populär, ein Makro NULL zu definieren, um den Nullzeiger zu representieren. [...] Wenn Sie meinen, NULL definieren zu müssen, dann...

Folglich gibt es kein NULL in C++.

mfg

#define NULL 0

Also es gibt NULL, auch in C++.
Eine Diskussion über NULL oder 0 gibt's in den FAQ

Gruß

dann ist aber auch schon wieder etwas schiefgelaufen, wenn ein zeiger zweimal deleted wird. deshalb sollte man einen zeiger nicht auf 0 setzen, damit soetwas entdeckt wird.

Auf 0 setzen ist durchaus legitim und oft sehr zu empfehlen. Wenn man in einer Klasse die Invariante "Pointer ist entweder gültig oder 0" festlegt, dann kann man ihn sofort nach dem delete auf 0 setzen und gewährleistet damit die Sicherheit der Klasse beim Auftreten von Exceptions.

struct some_stupid_class {
  A *a;
  some_stupid_class(): a(new A[10]) { }
  ~some_stupid_class() { delete[] a; }
  void resize(int n) {
    delete[] a;
    a = 0;
    a = new A[n];
  }
};

Wenn nun der Constructor von A eine Exception wirft und du das "a=0" weglässt, crasht das Ding im Destruktor.

Auf 0 setzen ist durchaus legitim und oft sehr zu empfehlen. Wenn man in einer Klasse die Invariante "Pointer ist entweder gültig oder 0" festlegt, dann kann man ihn sofort nach dem delete auf 0 setzen und gewährleistet damit die Sicherheit der Klasse beim Auftreten von Exceptions.

struct some_stupid_class {
  A *a;
  some_stupid_class(): a(new A[10]) { }
  ~some_stupid_class() { delete[] a; }
  void resize(int n) {
    delete[] a;
    a = 0;
    a = new A[n];
  }
};

Wenn nun der Constructor von A eine Exception wirft und du das "a=0" weglässt, crasht das Ding im Destruktor.

stimmt. aber wie oft schreibt man schon selber eine klasse, die dynamisch speicher anfordert? in 99% der fälle würde ich dieses problem der stl/... überlassen

mfg

Eine Diskussion über NULL oder 0 gibt's in den FAQ

*davonschleich*

mfg

terraner schrieb:

dann ist aber auch schon wieder etwas schiefgelaufen, wenn ein zeiger zweimal deleted wird. deshalb sollte man einen zeiger nicht auf 0 setzen, damit soetwas entdeckt wird.

Auf 0 setzen ist durchaus legitim und oft sehr zu empfehlen. Wenn man in einer Klasse die Invariante "Pointer ist entweder gültig oder 0" festlegt, dann kann man ihn sofort nach dem delete auf 0 setzen und gewährleistet damit die Sicherheit der Klasse beim Auftreten von Exceptions.

struct some_stupid_class {
  A *a;
  some_stupid_class(): a(new A[10]) { }
  ~some_stupid_class() { delete[] a; }
  void resize(int n) {
    delete[] a;
    a = 0;
    a = new A[n];
  }
};

Wenn nun der Constructor von A eine Exception wirft und du das "a=0" weglässt, crasht das Ding im Destruktor.

könnte sein, daß man durch umsortieren diese zuweisung immer wegkriegt.

struct some_stupid_class {
  A *a;
  some_stupid_class(): a(new A[10]) { }
  ~some_stupid_class() { delete[] a; }
  void resize(int n) {
    A* newA=new A[n];
    a=newA;
    delete[] newA;
  }
};