将对象添加到 std::list 时调用对象的析构函数

Question

我有一个 Foo 对象和一个保存它实例的 std::list 。 我的问题是，当我将新实例添加到列表中时，它首先调用 ctor，然后也调用 dtor。 然后是另一个实例上的 dtor（根据 this 指针）。

单个实例被添加到列表中，但由于调用了它的 dtor（及其父级），因此该对象无法按预期使用。

这是一些简化的代码来说明问题：

#include <iostream>
#include <list>

class Foo
{
public:
    Foo()
    { 
        int breakpoint = 0;
    }
    ~Foo()
    { 
        int breakpoint = 0;
    }
};

int main()
{
    std::list<Foo> li;
    li.push_back(Foo());
}

Answer 1

当您 Push_back() Foo 对象时，该对象将复制到列表的内部数据结构，因此调用另一个实例的 Dtor 和 Ctor。

C++ 中的所有标准 STL 容器类型都按值获取其项目，因此可以根据需要复制它们。 例如，每当向量需要增长时，向量中的所有值都可能被复制。

也许您想存储指针而不是列表中的对象。 通过这样做，只复制指针而不是对象。 但是，通过这样做，您必须确保在完成后删除对象：

for (std::list<Foo*>::iterator it = list.begin(); it != list.end(); ++it) {
    delete *it;
}
list.clear();

或者，您可以尝试使用某种“智能指针”类，例如来自 Boost 库的类。

Answer 2

您将在此处创建一个临时 Foo：

li.push_back( Foo() )

push_back 将该 Foo 复制到其内部数据结构中。 执行push_back后，临时Foo将被销毁，这将调用析构函数。

您将需要一个适当的复制构造函数，它可以增加您不想提前销毁的类成员的引用计数，或者将其设为私有以强制您采用指针解决方案。

Answer 3

使用这个对象来理解：

class Foo
{
public:
    Foo(int x): m_x(x)
    { 
    std::cout << "Constructed Object: " << m_x << ")\n";
    }
    Foo(Foo const& c): m_x(c.m_x+100)
    {
    std::cout << "Copied Object: " << m_x << ")\n";
    }
    ~Foo()
    {  
    std::cout << "Destroyed Object: " << m_x << ")\n";
    }
};

第一个 main

std::list<Foo*> li;
li.push_back(Foo(1));

这里我们创建一个临时的 Foo 对象并调用push_back()。 临时对象被复制到列表中并且函数返回。 完成此语句后，临时对象将被销毁（通过析构函数）。 当列表被销毁时，它也会销毁它包含的所有对象（Foo 是一个带有析构函数的对象，因此销毁包括调用析构函数）。

所以您应该看到类似这样的内容：

Constructed Object: 1
Constructed Object: 101
DestroyedObject: 1
DestroyedObject: 101

在第二个示例中，您可以看到：

std::list<Foo*> li;
li.push_back(new Foo(1));

这里您在堆上动态创建一个对象。 然后调用push_back()。 这里指针被复制到列表中（指针没有构造函数/析构函数），因此不会发生其他情况。 该列表现在包含指向堆上对象的指针。 当函数返回时，什么也不做。 当列表被销毁时，它会销毁（注意销毁和删除之间的细微差别）它包含的对象（指针），但指针没有析构函数，因此不会发生任何泄漏内存的情况。

所以你应该看到这样的东西：

Constructed Object: 1

Answer 4

这里实际发生的是，您将传递的对象的副本存储在列表中，因为您是按值而不是按引用发送它。 因此，第一个被调用的 dtor 实际上是在您传递给 Push_back 方法的对象上调用的，但此时已经创建了一个新实例，并且现在将其存储在列表中。

如果您不想创建 Foo 对象的副本，请在列表中存储指向 Foo 对象的指针，而不是对象本身。 当然，在执行此操作时，您必须在销毁列表时正确释放内存。

Answer 5

使列表保存指针而不是实例可以解决调用析构函数的问题。 但我仍然想了解为什么会发生这种情况。

#include <iostream>
#include <list>

class Foo
{
public:
    Foo()
    { 
        int breakpoint = 0;
    }
    ~Foo()
    { 
        int breakpoint = 0;
    }
};

int main()
{
    std::list<Foo*> li;
    li.push_back(new Foo());
}