Имеет ли std :: list :: remove метод вызова деструктора каждого удаленного элемента?

Question

std::list<Node *> lst;
//....
Node * node = /* get from somewhere pointer on my node */;
lst.remove(node);

Имеет ли std :: list :: remove метод деструктор (и освобождает память) каждого удаленного элемента? Если да, то как мне этого избежать?

Answer 1

Да, удаление Foo* из контейнера уничтожает Foo*, но не освобождает Foo.Уничтожение необработанного указателя - всегда - нет операции.Другого не может быть!Позвольте мне привести несколько причин, по которым:

Класс хранения

Удаление указателя имеет смысл только в том случае, если указатель фактически был выделен динамически, но как может среда выполнения узнать, так ли это, еслипеременная указателя уничтожена?Указатели также могут указывать на статические и автоматические переменные, и удаление одного из этих выводов неопределенное поведение .

{
    Foo x;
    Foo* p = &x;

    Foo* q = new Foo;

    // Has *q been allocated dynamically?
    // (The answer is YES, but the runtime doesn't know that.)

    // Has *p been allocated dynamically?
    // (The answer is NO, but the runtime doesn't know that.)
}

Висячие указатели

Нет способа выяснить,Пуанти был уже выпущен в прошлом.Удаление одного и того же указателя дважды приводит к неопределенному поведению .(Он становится висящим указателем после первого удаления.)

{
    Foo* p = new Foo;

    Foo* q = p;

    // Has *q already been released?
    // (The answer is NO, but the runtime doesn't know that.)

    // (...suppose that pointees WOULD be automatically released...)

    // Has *p already been released?
    // (The answer WOULD now be YES, but the runtime doesn't know that.)
}

Неинициализированные указатели

Также невозможно определить, была ли вообще указана переменная-указатель,Угадайте, что происходит, когда вы пытаетесь удалить такой указатель?Еще раз, ответ: неопределенное поведение .

    {
        Foo* p;

        // Has p been properly initialized?
        // (The answer is NO, but the runtime doesn't know that.)
    }

Динамические массивы

Система типов не различает указатель на один объект (Foo*)и указатель на первый элемент массива объектов (также Foo*).Когда переменная-указатель уничтожается, среда выполнения не может выяснить, следует ли освободить указатель через delete или через delete[].Выпуск через неправильную форму вызывает неопределенное поведение .

{
    Foo* p = new Foo;

    Foo* q = new Foo[100];

    // What should I do, delete q or delete[] q?
    // (The answer is delete[] q, but the runtime doesn't know that.)

    // What should I do, delete p or delete[] p?
    // (The answer is delete p, but the runtime doesn't know that.)
}

Сводка

Так как среда выполнения не может сделать ничего разумного с pointee, уничтожение переменной указателя равно всегда нет опер.Ничего не делать определенно лучше, чем вызывать неопределенное поведение из-за неосведомленного предположения: -)

Совет

Вместо необработанных указателей рассмотрите возможность использования интеллектуальных указателей в качестве типа значения вашего контейнера, поскольку они принимаютответственность за освобождение пуантина, когда он больше не нужен.В зависимости от ваших потребностей, используйте std::shared_ptr<Foo> или std::unique_ptr<Foo>.Если ваш компилятор еще не поддерживает C ++ 0x, используйте boost::shared_ptr<Foo>.

Никогда , повторяю, НИКОГДА НЕ используйте std::auto_ptr<Foo> в качестве типа значенияконтейнера.

Answer 2

Он вызывает деструктор каждого из элементов в list - но это не объект Node. Это Node*.

Таким образом, он не удаляет указатели Node.

Имеет ли это смысл?

Answer 3

Вызывает деструктор данных в списке. Это означает, что std::list<T>::remove вызовет деструктор T (что необходимо, когда T что-то типа std::vector).

В вашем случае это вызвало бы деструктор Node*, который не используется. Это не вызывает деструктор node.

Answer 4

Да, хотя в этом случае Node * не имеет деструктора. В зависимости от его внутренних свойств, различные значения Node * либо удаляются, либо уничтожаются по правилам области видимости. Если Node *, где какой-то неосновной тип, будет вызван деструктор.

Деструктор вызван на Узел? Нет, но «Node» не является типом элемента в списке.

Что касается вашего другого вопроса, вы не можете. Стандартный контейнер списка (фактически ВСЕ стандартные контейнеры) принимает право собственности на свой контент и очищает его. Если вы не хотите, чтобы это происходило, стандартные контейнеры не являются хорошим выбором.

Answer 5

Лучший способ понять это проверить каждую форму и наблюдать за результатами.Чтобы умело использовать объекты-контейнеры с вашими собственными объектами, вам необходимо хорошо понимать поведение.

Короче говоря, для типа Node* не вызывается деконструктор и не вызывается delete / free;однако для типа Node будет вызываться деконструктор, в то время как рассмотрение удаления / освобождения является подробностью реализации списка.Это означает, что это зависит от того, использовала ли реализация списка new / malloc.

. В случае unique_ptr<Node> вызывается деконструктор и происходит вызов delete / free, поскольку вам нужно было что-то выделить для него.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;
}

Обратите особое внимание на адреса памяти.Вы можете определить, какие из них указывают в стек, а какие - в кучи по диапазонам.

Answer 6

Поскольку вы помещаете указатели в std::list, деструкторы не вызываются для Node объектов, на которые указывает указатель.

Если вы хотите сохранить выделенные объекты кучи в контейнерах STL и уничтожить их при удалении, оберните их в интеллектуальный указатель, например boost::shared_ptr