Konsequente Verwendung von std :: list verursacht Absturz

Question

Ich habe Code, der Speicherverwaltung tun soll, aber es stürzt immer an einem bestimmten Punkt ab, wo ich ein Objekt aus der "Live" -Liste entfernen und auf den "Toten" platziere ein:

class MemoryObject { 
private: 
    static std::list <MemoryObject *> alive, dead; 
    long references; 
public: 
    MemoryObject() { 
     alive.push_back(this); 
     references = 0; 
    } 

    static void deepClean() { 
     clean(); 
     std::list<MemoryObject *>::iterator iterator; 
     for(iterator = alive.begin(); iterator != alive.end(); iterator ++) { 
      MemoryObject *object = *iterator; 
      Log::instance().write(DEBUG_LOG, "\nObject still active at the end of the program, check for memory leaks." 
        "\nSize: %d", 
        alive.size()); 
      delete object; 
     } 
     alive.clear(); 
    } 

    void reference() { 
     references ++; 
    } 

    void release() { 
     references --; 
     if(references <= 0) { 
      dead.push_back(this); 
      alive.remove(this); 
     } 
    } 

    static void clean() { 
     std::list<MemoryObject *>::iterator iterator; 
     for(iterator = dead.begin(); iterator != dead.end(); iterator ++) 
      delete(&iterator); 
     dead.clear(); 
    } 

    ~MemoryObject() { 
     clean(); 
    } 
}; 

std::list <MemoryObject *> MemoryObject::alive, MemoryObject::dead; 

Eclipse-Debug zeigt es unter Release(), immer auf der zweiten Liste bezogenen Stelle versagt - ich habe versucht, sie (alive.remove(this) and dead.push_back(this)) in einer anderen Reihenfolge, die sich nichts ändert setzen. Interessanterweise jedoch, wenn ich etwas dazwischen ihnen legen, wie eine printf() Aussage, es nicht abstürzen ...

hier, wo ich rufe aus:

#include <stdlib.h> 
#include <stdio.h> 

#include "log/log.hpp" 
#include "memory/object.hpp" 

int main(int argc, char *argv[]) { 
    MemoryObject foo; 
    foo.release(); 
    MemoryObject::deepClean(); 
    return 0; 
} 

Answer 1

Sie delete nur was durch new zugeordnet ist.

MemoryObject foo; 
foo.release(); 

Und innen sauber

for(iterator = dead.begin(); iterator != dead.end(); iterator ++) 
     delete(*iterator); //I am assuming you have * instead of &(which is incorrect as mentioned in another answer). 

So sind Sie delete() auf etwas rufen, die nicht durch new Versuchen Sie, diese zugeordnet wurde.

MemoryObject *foo=new MemoryObject(); 
foo->release(); 

EDIT: Dies funktioniert immer noch nicht aus dem folgenden Grund.

Innen clean() Sie löschen Element dead die this des aktuellen object.So ist kurzum Sie so etwas wie dieses

class A 
{ 
    void delete_this() 
    { 
     delete(this); 
     //At this point "this" is a dangling pointer and you should not use it. 
    } 
}; 

Answer 2

In Ihrem clean Funktion, die Sie haben:

delete(&iterator); 

das kompiliert, aber versucht, den Iterator selbst zu löschen - die auf dem Stapel befindet (was zum Absturz bringen).

Ich vermute, man wollte:

delete(*iterator); 

Answer 3

Sie können nicht ein Objekt löschen, die nicht mit neuen zugeordnet wurde. MemoryObject foo; ist nicht mit new neu zugeordnet.