Destruktor C++: type '* * * ' - argument gegeben, um 'löschen', erwartet Zeiger

Als ich erklärte, dass eine private variable

vector<SomeClass> theVector;

irgendwo in meinem SomeClass-Klasse.

Warum kann ich nicht sagen: delete theVector in meinem SomeClass Destruktor?

Die compiler-Fehlermeldung lautet:

 type `class Vector<SomeClass>' argument given to `delete', expected pointer

Was erwartet Zeiger?

"erwartet" pointer " bedeutet, dass der compiler erwartet einen Zeiger, wo etwas anderes angegeben wurde. Es ist nicht zu sagen, "erwartet" Zeiger gegeben wurde, zu löschen.
Ich empfehle Ihnen, Lesen Sie gnomesane.net/code/doc/ptrarray, es wird erklärt, wie Zeiger und Referenzen funktionieren.

InformationsquelleAutor andandandand | 2008-12-20

c++destructor

19

Wenn new und delete gehen hand in hand.

Um etwas zu löschen, müssen Sie ihn erstellen über neue (gibt Sie einen Zeiger). Löschen Sie anschließend den Mauszeiger. Die Art und Weise erklären Sie die vector-es wird auf dem Stapel erzeugt (nicht auf dem heap) und wird freigegeben, wenn es den Bereich verlässt.
```
int main()
{
    vector<SomeClass> theVector;

    vector<SomeClass>* ptrVctor = new vector<SomeClass>();


    delete ptrVctor;   //ptrVctor must be deleted manually
    //theVector destroyed automatically here
}
```
- Würde diese löschen ptrVctor Ursache der Speicher für den Vektor befreit zu werden?
- *Angenommen, der neue ist auf dem SomeClass Konstruktor und delete prtVector ist auf der SomeClass Destruktor.
- Beide Beispiele oben de-allocate all die Erinnerung.
- Neuer Speicher reserviert, dann ruft automatisch den contructor. Delete ruft den Destruktor dann gibt den verwendeten Speicher wieder an das system. Hinweis: die STL-Container besitzen alle Objekte, die in Ihnen platziert. Also, wenn der Destruktor aufgerufen wird es zerstört auch alle Objekte.
- Ja, lokale Variablen, die nicht zugeordnet mit 'neuen' bekommen, wird automatisch freigegeben, wenn Sie den Gültigkeitsbereich verlässt. Also immer nur verwenden, löschen Sie mit etwas, das Sie neue ' ed.
- Die OP hat eine private member-variable ist, so könnte es auf dem Stapel oder der heap (je nachdem, wie die Klasse-Instanz erstellt wurde). @dmindreader.blogspot.com, ptrVctr ist nicht gelöscht, aber die Daten, die er verweist ist.
- ist der SomeClass Destruktor automatisch aufgerufen, wenn theVector geht out of scope?
- Ja. Wenn der Vektor zerstört. Alle Objekte, die es besitzt (alles, was es enthält) werden auch zerstört werden (via Destruktor).
InformationsquelleAutor Martin York
8

In C++ (im Gegensatz zu Java), können Sie Objekte erstellen, die entweder auf dem stack oder auf dem heap. Ein Beispiel für das erstellen Sie auf dem Stapel ist, wie Sie getan haben:
```
vector<SomeClass> theVector;
```
Diesem Objekt den Gültigkeitsbereich verlässt, wenn der stack-frame verschwindet (in der Regel, wenn Sie zurückkehren aus der Funktion, die das Objekt erstellt hat.

Erstellen von Objekten auf dem heap erlaubt Ihnen, überlebt die Funktion, die Sie erstellt haben, und Sie tun, indem Sie:
```
vector<SomeClass> *theVectorPtr = new vector<SomeClass>();
```
Dann können Sie passieren die theVectorPtr Zeiger wieder an den Aufrufer der Funktion (oder speichern Sie es Global, was auch immer Sie wollen).

In, um loszuwerden, das Objekt auf dem heap explizit zu löschen es:
```
delete theVectorPtr;
```
irgendwo im code.

Löschen eines Objekts auf dem heap, endet der Gültigkeitsbereich des Objekts, auf die gleiche Weise der Rückkehr aus einer Funktion endet der Gültigkeitsbereich von Variablen auf dem Stapel erzeugt.
- Wie wird sich die situation ändern, wenn wir vector<SomeClass*> theVectorPtr = new vector<SomeClass>(); Wird delete theVectorPtr Arbeit hier auch?
- es kann gearbeitet haben, aber du wirst nie wissen 🙂 new gibt Sie einen Zeiger, und Sie versuchen, ordnen Sie einen Vektor anstatt einer Vektor-Zeiger. Das wird nicht mal kompilieren. Wenn Sie ihn wieder in einen Zeiger, es zu lösen, aber dann ist der Typ innerhalb der Vektor nicht mit. Versuchen std::vector<SomeClass*> *v = new std::vector<SomeClass*>(); - und Sie werden auch in der Lage sein, um es zu löschen, aber möchten Sie vielleicht, um sicherzustellen, dass Sie das löschen der Zeiger innerhalb der Vektor-ersten.
InformationsquelleAutor paxdiablo
3

Wenn ein Objekt (nicht als Wert) ist definiert als eine Klasse member-variable ist, dann sind deren Speicher ist immer gebunden an das Objekt Instanz der Klasse.

Daher, wenn das enthaltende Objekt auf dem Stapel reserviert ist, wird das Objekt und der Bereich wird sterben, wenn der stack entrollt.

Wenn das enthaltende Objekt zugewiesen ist, auf den Haufen, und dann das field-Objekt wird sterben, wenn das gesamte enthaltene Objekt stirbt mit löschen.

Werden Sie nur die Anwendung zu löschen, um ein Feld, wenn, dass ist ein Zeiger, da alle, die gespeichert wird mit dem enthaltenden Objekt ist die Adresse einiger anderer Speicher, und löschen Sie die Materialien in diesem Bereich.

InformationsquelleAutor Uri
2

Den Speicher für theVector Teil der Speicher für die SomeClass Objekt, so können Sie nicht löschen, ohne löschen der gesamten SomeClass Objekt. Der Speicher für theVector erhalten automatisch freigegeben, wenn das SomeClass Objekt ist zerstört.
- Tatsächlich, Sie KÖNNEN zerstören theVector, während 'dies' noch Leben, aber das ist wahrscheinlich nicht das, was eine person von diesem skill-level zu tun. =]
InformationsquelleAutor David Norman
2

Zerstören alle Objekte, die statt in den Vektor möchten, führen Sie die folgenden:
```
theVector.resize(0);
```
Geschieht dies automatisch, wenn der Vektor geht out of scope.

InformationsquelleAutor
1

Dies ist, weil theVector ist kein Zeiger, das ist, was delete' expects. "Expected pointer" means the operand oflöschen' muss ein Zeiger.

Vergleichen
```
int theInt;
delete theInt;
```
Es wird sicher einen Fehler erzeugen, ähnlich dem, was Sie bekam.

InformationsquelleAutor PolyThinker
1

c++ gibt Ihnen die Flexibilität zum erstellen von Objekt im stack und heap.
Beim erstellen der Objekte im heap durch den new-operator, wie unten gezeigt, es gibt den Zeiger auf das Objekt im heap.
```
ClassA * pobj_class = new ClassA();
```
Für das Objekt erstellt, in der stack-Konstruktor gibt das Objekt zurück, anstatt Zeiger wie unten gezeigt.
```
ClassA obj_class();
```
- und stack-Objekt automatisch zerstört, wenn die variable(obj_class) geht out of scope,aber Objekt erstellt heap Leben für immer.So zerstören heap-Objekt-c++ haben Sie die delete-operator nimmt pointer als argument und zerstört das Objekt, das der Zeiger verweist.

InformationsquelleAutor yesraaj

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.