std :: list :: remove方法是否调用每个被删除元素的析构函数？

时间：2010-11-23 20:16:18

标签： c++ list stl destructor c++-faq 

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

std :: list :: remove方法是否调用每个被删除元素的析构函数（和空闲内存）？如果是，我怎么能避免呢？

6 个答案:

答案 0 :(得分：44)

是的，从容器中删除Foo*会破坏Foo*，但不会释放Foo。销毁原始指针总是一个无操作。它不能是任何其他方式！让我告诉你几个原因。

存储类

如果指针实际上是动态分配的，那么删除指针才有意义，但是当指针变量被销毁时，运行时怎么可能知道是否就是这种情况？指针也可以指向静态变量和自动变量，并删除其中一个变量undefined behavior。

{
    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.)
}

悬空指针

无法确定指针对象是否已在过去发布。删除相同的指针两次会产生undefined behavior。 （第一次删除后它变为悬空指针。）

{
    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.)
}

未初始化的指针

也无法检测指针变量是否已初始化。猜猜当你试图删除这样的指针时会发生什么？再一次，答案是undefined behavior。

    {
        Foo* p;

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

动态数组

类型系统不区分指向单个对象（Foo*）的指针和指向对象数组的第一个元素（也是Foo*）的指针。当指针变量被销毁时，运行时无法确定是通过delete还是通过delete[]释放指针。通过错误的表单发布会调用undefined behavior。

{
    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.)
}

摘要

由于运行时无法对指针对象做任何事情，因此销毁指针变量总是一个无操作。无所事事肯定比由于不知情的猜测导致未定义的行为更好： - ）

建议

考虑使用智能指针作为容器的值类型，而不是原始指针，因为它们负责在不再需要时释放指针。根据您的需要，使用std::shared_ptr<Foo>或std::unique_ptr<Foo>。如果您的编译器尚不支持C ++ 0x，请使用boost::shared_ptr<Foo>。

Never，我再说一遍，永远不会使用std::auto_ptr<Foo>作为容器的值类型。

答案 1 :(得分：12)

它调用list中每个项目的析构函数 - 但这不是Node对象。它是Node*。

所以它不会删除Node指针。

这有意义吗？

答案 2 :(得分：7)

它会调用列表中数据的析构函数。这意味着，std::list<T>::remove将调用T的析构函数（当T类似于std::vector时，这是必需的。）

在你的情况下，它会调用Node*的析构函数，这是一个无操作。它不会调用node的析构函数。

答案 3 :(得分：3)

是的，虽然在这种情况下，Node *没有析构函数。但是，根据其内部结构，各种Node *值将被范围规则删除或销毁。如果Node *中有一些非基本类型，则会调用析构函数。

是否在节点上调用了析构函数？不，但“节点”不是列表中的元素类型。

关于你的另一个问题，你不能。标准列表容器（实际上是所有标准容器）采用其内容的所有权并将其清理。如果您不希望发生这种情况，标准容器不是一个好的选择。

答案 4 :(得分：0)

由于您将指针放入std::list，因此不会在指向Node对象上调用析构函数。

如果要将堆分配的对象存储在STL容器中并在删除时将其解除，请将它们包装在智能指针中，如boost::shared_ptr

答案 5 :(得分：0)

理解的最佳方法是测试每个表格并观察结果。要巧妙地将容器对象与您自己的自定义对象一起使用，您需要对行为有一个很好的理解。

简而言之，对于类型Node*，既不调用解构函数也不调用delete / free;但是，对于类型Node，将调用解构函数，而delete / free的考虑是列表的实现细节。这意味着，它取决于列表实现是否使用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;
}

请注意内存地址。你可以知道哪些指向堆栈，哪些指向堆中的范围。

相关问题
最新问题