Exception wird beim Freigeben des Heap mit delete xxx geworfen

[ledi001]

Hallo,
ich übe mich gerade im Umgang mit der dynamischen Speicherverwaltung und ich erhalte eine Ausnahme,
( [Die unten aufgeführten Frames sind möglicherweise nicht korrekt und/oder fehlen, für "ntdll.dll" wurden keine Symbole geladen.] Unbekannt)

wenn ich mit delete ptr; den Speicher am Heap freigeben möchte.

Hier mein Code Beispiel:

	int *ptr{nullptr};			// int-Pointer erstellen
	ptr = new int;				// Speicher für eine int-Speicherstelle am heap reservieren

	cout << ptr << endl;		// Adresse des int-Pointers am heap ausgeben
	cout << *ptr << endl;		// Inhalt des int-Pointers ausgeben - garbage

	*ptr = 100;					// 100 an die Adresse dereferenzieren
	ptr++;						// ptr inkrementieren
	*ptr = 200;					// 200 an die Adresse ptr + 1 dereferenzieren
	ptr++;						// ptr inkrementieren
	*ptr = 300;					// 300 an die Adresse ptr + 2 dereferenzieren

	cout << *ptr << endl;		// 300
	ptr--;						// ptr dekrementieren
	cout << *ptr << endl;		// 200
	ptr--;						// ptr dekrementieren
	cout << *ptr << endl;		// 100

	delete ptr;					// Speicher am heap freigeben

Kann mir jemand sagen, was ich hier falsch mache? Danke!

[Ein ehemaliger Benutzer]

@ledi001 sagte in Exception wird beim Freigeben des Heap mit delete xxx geworfen:

ptr++;						// ptr inkrementieren
*ptr = 200;					// 200 an die Adresse ptr + 1 dereferenzieren

Wieviele int hast du?

[ledi001]

@manni66
Ich verstehe jetzt deine Frage nicht genau.

[Jockelx]

@ledi001

Genauer gefragt: Für wieviele int hast du Platz reserviert?

[ledi001]

in dem Fall für einen.
D.h. ich darf mit ptr++ nicht einfach auf eine neue Speicherstelle referenzieren ohne vorher dafür Platz am Heap zu reservieren?

[Ein ehemaliger Benutzer]

@ledi001 sagte in Exception wird beim Freigeben des Heap mit delete xxx geworfen:

D.h. ich darf mit ptr++ nicht einfach auf eine neue Speicherstelle referenzieren ohne vorher dafür Platz am Heap zu reservieren?

Warum überrascht dich das?

Dur darfst natürlich auch nicht einfach delete auf ptr aufrufen, wenn er nicht auf den Anfabg zeigt.

Benutze std::vector.

[ledi001]

OK, Danke!

Eine Frage noch.

Wenn ich den Speicher am heap für ein Array freigebe
mache ich das mit delete myArray oder delete [] myArray;? bzw. was ist der Unterschied?

int *myArray = new int[4];	// Array für 4 Elemente am heap reservieren

delete [] myArray;		// Speicher am heap freigeben

[yahendrik]

@ledi001 Der Unterschied ist, dass delete nur das erste Element löschen würde. delete [] myArray; ist also richtig. Siehe https://ideone.com/9JzQUW.
Es gibt aber wesentlich bessere Alternativen:

#include <array>
#include <vector>

int main()
{
  std::vector<int> myvector(4);
  // falls N zur Kompilierzeit festesteht
  std::array<int, 4> myarray;

}  // es muss nichts freigegeben werden, das geschieht automatisch (Stichwort RAII).

[Jockelx]

@ledi001 sagte in Exception wird beim Freigeben des Heap mit delete xxx geworfen:

was ist der Unterschied?

Das eine ist richtig (delete[]), das andere ist falsch.

Und noch der obligatorische Hinweis, dass man das, was du da gerade machst, so gut wie nie das ist, was man in einem 'echten' Programm nutzen sollte. Manni hat das Stichwort ja schon gegeben: std::vector.

[wob]

Neben std::vector gibt es auch noch std::make_unique<int[]>(4), wenn du sicher bist, dass du exakt 4 Elemente brauchst.

Jedenfalls solltest du vermeiden, von Hand new und delete / delete[] aufzurufen. Man kann zu leicht Fehler machen (zum Beispiel delete mit delete[] verwechseln, delete mehrfach oder gar nicht aufrufen).

In 99% der Fälle wird std::vector das richtige sein.