Löschen eines Zeigers in C ++

Kontext: ich versuche, wickeln Sie meinen Kopf herum, Zeiger, wir sahen Sie vor ein paar Wochen in der Schule und beim üben heute lief ich in eine dumme? Frage, kann es super einfach für Sie, aber ich habe wenig bis keine Programmiererfahrung.

Ich habe gesehen, durchaus ein paar Fragen mehr in SO über das löschen von Zeigern, aber Sie alle scheinen mit dem löschen einer Klasse und nicht eine "einfache" Zeiger (oder was auch immer der richtige Begriff sein mag), hier ist der code, den ich versuche zu laufen:

#include <iostream>;

using namespace std;

int main() {
  int myVar,
      *myPointer;

  myVar = 8;
  myPointer = &myVar;

  cout << "delete-ing pointers " << endl;
  cout << "Memory address: " << myPointer << endl;

  //Seems I can't *just* delete it, as it triggers an error 
  delete myPointer;
  cout << "myPointer: " << myPointer << endl;
  //Error: a.out(14399) malloc: *** error for object 0x7fff61e537f4:
  //pointer being freed was not allocated
  //*** set a breakpoint in malloc_error_break to debug
  //Abort trap: 6

  //Using the new keyword befor deleting it works, but
  //does it really frees up the space? 
  myPointer = new int;
  delete myPointer;
  cout << "myPointer: " << myPointer << endl;
  //myPointer continues to store a memory address.

  //Using NULL before deleting it, seems to work. 
  myPointer = NULL;
  delete myPointer;
  cout << "myPointer: " << myPointer << endl;
  //myPointer returns 0.

}

Also meine Fragen sind:

Warum nicht der erste Fall arbeiten? Scheint die einfache Anwendung zu verwenden und zu löschen ein Zeiger? Die Fehlermeldung sagt das der Speicher nicht reserviert, aber 'cout' zurückgegebene Adresse.
Auf das zweite Beispiel wird der Fehler nicht ausgelöst wird, aber dabei eine cout der Wert von myPointer noch gibt eine Speicher-Adresse?
Tut #3 wirklich funktionieren? Scheint zu funktionieren für mich, der Zeiger ist nicht mehr die Speicherung einer Adresse, ist das die richtige Art und Weise zu löschen ein Zeiger?

Sorry für die lange Frage, wollte dies so klar wie möglich, auch zu bekräftigen, habe ich wenig Programmiererfahrung, so dass, wenn jemand beantworten könnte, dies mit einfachen Worten gesagt, es würde sehr geschätzt werden!

InformationsquelleAutor der Frage leopic | 2012-11-04

c++delete-operator pointers

116

1 & 2
```
myVar = 8; //not dynamically allocated. Can't call delete on it.
myPointer = new int; //dynamically allocated, can call delete on it.
```
Die erste variable auf dem Stapel reserviert. Sie nennen können, löschen Sie nur Speicher, den Sie reserviert dynamisch (auf dem heap) mit der new Betreiber.

3.
```
  myPointer = NULL;
  delete myPointer;
```
Oben hat gar nichts. Sie hat nicht alles kostenlos, wie der Zeiger zeigte auf NULL.

Die folgenden nicht getan werden sollte:
```
myPointer = new int;
myPointer = NULL; //leaked memory, no pointer to above int
delete myPointer; //no point at all
```
Du wies er bei NULL, so dass hinter Speicherbelegung (new int Sie zugeordnet sind).
Sie sollten den Speicher frei, waren Sie gerichtet. Gibt es keine Möglichkeit, dass der Zugang zugewiesen new int mehr, daher Speicherverlust.

Der richtige Weg:
```
myPointer = new int;
delete myPointer; //freed memory
myPointer = NULL; //pointed dangling ptr to NULL
```
Der bessere Weg:

Wenn Sie mit C++, nicht raw-Pointer. Verwenden intelligente Zeiger statt, die diese Dinge für Sie, mit wenig Aufwand. C++11 kommt mit mehrere.

InformationsquelleAutor der Antwort Anirudh Ramanathan
14

Ich glaube du hast nicht ganz verstanden, wie Zeiger arbeiten.

Wenn Sie einen Zeiger auf Speicher es gibt drei verschiedene Dinge, die Sie verstehen müssen:

- es ist "was ist spitz", indem Sie den Mauszeiger (der Speicher)

- diese Speicher-Adresse

- nicht alle Zeiger haben müssen, Ihr Gedächtnis gelöscht: nur löschen müssen, um Speicher, der dynamisch zugewiesen werden (verwendet new Betreiber).

Vorstellen:
```
int *ptr = new int; 
//ptr has the address of the memory.
//at this point, the actual memory doesn't have anything.
*ptr = 8;
//you're assigning the integer 8 into that memory.
delete ptr;
//you are only deleting the memory.
//at this point the pointer still has the same memory address (as you could
//  notice from your 2nd test) but what inside that memory is gone!
```
Wenn du hast
```
ptr = NULL;
//you didn't delete the memory
//you're only saying that this pointer is now pointing to "nowhere".
//the memory that was pointed by this pointer is now lost.
```
C++ erlaubt es, dass Sie versuchen zu delete einen Zeiger, Punkte zu null aber es hat nicht wirklich etwas zu tun, gibt keine Fehler.

InformationsquelleAutor der Antwort salgadokk
10

Zeiger sind ähnlich wie bei normalen Variablen, dass Sie nicht brauchen, um Sie zu löschen. Sie werden aus dem Speicher entfernt, am Ende einer Funktionen die Ausführung und/oder das Ende des Programms.

Allerdings kann man Zeiger verwenden sollen einen 'block' von Speicher, wie zum Beispiel diese:
```
int *some_integers = new int[20000]
```
So weisen Sie Speicherplatz für 20000 zahlen. Nützlich, weil der Stack hat eine begrenzte Größe, und möchten Sie vielleicht, um Chaos über mit einer großen Ladung 'ints' ohne einen stack-überlauf-Fehler.

Jedem Aufruf neu, Sie sollten dann 'löschen', am Ende von Ihrem Programm, weil Sie sonst erhalten Sie ein Speicher-Leck, und einige zugewiesenen Speicherplatz wird nie wieder für andere Programme verwenden. Um dies zu tun:
```
delete [] some_integers;
```
Hoffe, das hilft.

InformationsquelleAutor der Antwort user3728501
7

Gibt es eine Regel in C++, für jeden neue es ist ein löschen.
1. Warum nicht der erste Fall arbeiten? Scheint die einfache Anwendung zu verwenden und zu löschen ein Zeiger? Die Fehlermeldung sagt das der Speicher nicht reserviert, aber 'cout' zurückgegebene Adresse.
neue wird nie aufgerufen. Also die Adresse, die cout-prints ist die Adresse des Speicherplatzes von myVar, oder der Wert zugewiesen myPointer in diesem Fall. Schriftlich:
```
myPointer = &myVar;
```
Ihnen sagen:

myPointer = Die Adresse, wo die Daten in myVar gespeichert ist
1. Auf das zweite Beispiel wird der Fehler nicht ausgelöst wird, aber dabei eine cout der Wert von myPointer noch gibt eine Speicher-Adresse?
Gibt es eine Adresse, die Punkte auf einem Speicherplatz, der gelöscht wurde. Weil zuerst legen Sie den Zeiger und vergeben Sie seinen Wert auf myPointer, zweiten Sie ihn löschen, können Dritte Sie es drucken. Also, es sei denn Sie weisen einen anderen Wert, um myPointer, die gelöschte Adresse wird bleiben.
1. Tut #3 wirklich funktionieren? Scheint zu funktionieren für mich, der Zeiger ist nicht mehr die Speicherung einer Adresse, ist das die richtige Art und Weise zu löschen ein Zeiger?
NULL gleich 0, Sie löschen auf 0, so dass Sie nichts löschen. Und es ist die Logik, dass es druckt 0, weil du es getan hast:
```
myPointer = NULL;
```
entspricht:
```
myPointer = 0;
```
InformationsquelleAutor der Antwort fonZ
4
1. Sie versuchen, löschen einer Variablen auf dem Stapel reserviert. Sie kann dies nicht tun
2. Löschen ein Zeiger nicht zerstört einen Zeiger eigentlich nur der belegte Speicher wird wieder dem OS. Sie können darauf zugreifen, bis der Speicher für eine andere variable oder anderweitig bearbeitet werden. So ist es gute Praxis, um einen Zeiger auf NULL (0) nach dem löschen.
3. Das löschen eines NULL-Zeigers löscht nicht alles.
InformationsquelleAutor der Antwort Hakan Serce

int value, *ptr;

value = 8;
ptr = &value;
//ptr points to value, which lives on a stack frame.
//you are not responsible for managing its lifetime.

ptr = new int;
delete ptr;
//yes this is the normal way to manage the lifetime of
//dynamically allocated memory, you new'ed it, you delete it.

ptr = nullptr;
delete ptr;
//this is illogical, essentially you are saying delete nothing.

InformationsquelleAutor der Antwort Casper Beyer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.