Ist std :: list :: remove Methodenaufrufdestruktor für jedes entfernte Element?

Ruft er den Destruktor jedes der Elemente in der list - aber das ist nicht ein Node Objekt. Seine eine Node*.

So ist es nicht löschen Sie die Node Zeiger.

Macht das Sinn?

InformationsquelleAutor der Antwort John Dibling

Ja, obwohl in diesem Fall Knoten* hat keinen Destruktor. Je nach Interna obwohl die verschiedenen Knoten* Werte werden entweder gelöscht oder zerstört durch die scoping-Regeln. Wenn Knoten*, wo einige nicht-fundamentalen Typ, ein Destruktor aufgerufen werden würde.

Wird der Destruktor aufgerufen, der Knoten? Nein, aber 'Knoten' ist nicht der element-Typ in der Liste.

Als zu Ihrer anderen Frage, kann man nicht. Die standard-Liste-container (in der Tat ALLE standard-Container) übernehmen Verantwortung für Ihre Inhalte und reinigen Sie es bis. Wenn Sie nicht möchten, dass dies geschehen kann, muss die standard-Container sind nicht eine gute Wahl.

InformationsquelleAutor der Antwort Crazy Eddie

Der beste Weg zu verstehen ist, um zu testen, jedes Formular, und beobachten Sie die Ergebnisse. Gekonnt verwenden Sie die container-Objekte mit eigenen, benutzerdefinierten Objekten müssen Sie ein gutes Verständnis für das Verhalten.

Kurz gesagt, für die Art Node* weder der deconstructor heißt noch löschen/free wird aufgerufen, allerdings für die Art Node den deconstructor würde aufgerufen werden, während die Berücksichtigung löschen/free ist eine Implementierung detail-Liste. Bedeutung, es hängt davon ab, ob die Liste der Implementierung verwendet new/malloc.

Im Falle einer unique_ptr<Node>der deconstructor wird aufgerufen und der Aufruf von delete/free passieren wird, da Sie hatte, um ihm etwas zugeteilt new.

#include <iostream>
#include <list>
#include <memory>

using namespace std;

void* operator new(size_t size) {
    cout << "new operator with size " << size << endl;
    return malloc(size);
}

void operator delete(void *ptr) {
    cout << "delete operator for " << ptr << endl;
    free(ptr);
}

class Apple {
public:
    int id;

    Apple() : id(0) { cout << "apple " << this << ":" << this->id << " constructed" << endl; } 
    Apple(int id) : id(id) { cout << "apple " << this << ":" << this->id << " constructed" << endl; }
    ~Apple() { cout << "apple " << this << ":" << this->id << " deconstructed" << endl; }

    bool operator==(const Apple &right) {
        return this->id == right.id;
    }

    static void* operator new(size_t size) {
        cout << "new was called for Apple" << endl;
        return malloc(size);
    }

    static void operator delete(void *ptr) {
        cout << "delete was called for Apple" << endl;
        free(ptr);
    }
    /*
        The compiler generates one of these and simply assignments
        member variable. Think memcpy. It can be disabled by uncommenting
        the below requiring the usage of std::move or one can be implemented.
    */
    //Apple& operator=(const Apple &from) = delete;
};

int main() {
    list<Apple*> a = list<Apple*>();

    /* deconstructor not called */
    /* memory not released using delete */
    cout << "test 1" << endl;
    a.push_back(new Apple());
    a.pop_back();

    /* deconstructor not called */
    /* memory not released using delete */
    cout << "test 2" << endl;
    Apple *b = new Apple();
    a.push_back(b);
    a.remove(b);
    cout << "list size is now " << a.size() << endl;

    list<Apple> c = list<Apple>();      
    cout << "test 3" << endl;
    c.push_back(Apple(1)); /* deconstructed after copy by value (memcpy like) */
    c.push_back(Apple(2)); /* deconstructed after copy by value (memcpy like) */

    /*
       the list implementation will call new... but not
       call constructor when Apple(2) is pushed; however,
       delete will be called; since it was copied by value
       in the last push_back call

       double deconstructor on object with same data
    */
    c.pop_back();

    Apple z(10);

    /* will remove nothing */
    c.remove(z);

    cout << "test 4" << endl;

    /* Apple(5) will never deconstruct. It was literally overwritten by Apple(1). */
    /* Think memcpy... but not exactly. */
    z = Apple(1);

    /* will remove by matching using the operator== of Apple or default operator== */
    c.remove(z);

    cout << "test 5" << endl;
    list<unique_ptr<Apple>> d = list<unique_ptr<Apple>>();
    d.push_back(unique_ptr<Apple>(new Apple()));
    d.pop_back();

    /* z deconstructs */
    return 0;
}

Achten Sie auf die Speicher-Adressen. Man kann sagen, die zeigen in den stack und die zeigen in den heap durch die Bereiche.

InformationsquelleAutor der Antwort kmcguire