std::vector 破坏和意外 Memory 泄漏

Question

考虑以下示例：

#include <vector>
class Foo {
    std::vector<int*> v;
public:
    Foo() {
        this->v.push_back(new int(23));
        this->v.push_back(new int(24));
        this->v.push_back(new int(25));
    }

    ~Foo() {
    }
};

int main() {
    Foo f;
    return 0;
}

当 f 在 main() 中超出 scope 时，会调用 f 的析构函数，它应该间接释放 fv 根据这个，现在应该调用向量 v 的每个元素的析构函数。

然而，当我在 valgrind 中运行这个程序时，我发现 int* 没有被释放。

$ valgrind --leak-check=full ./a.out

我在这里想念什么？

Answer 1

std::vector<T>在销毁时确实调用了T的析构函数。 这里T是int * 。 int *的析构函数什么都不做。 int *本身的存储空间被释放，但它们指向的int s 没有。

考虑：

int main() {
   int *x = new int(23);
   return 0;
}

这表现出同样的问题； 当x超出 scope 时，它的析构函数确实被调用，并且指针x的存储空间被释放，但由于指针的析构函数是空操作，指向的int没有被释放。

更重要的是， vector不知道int是如何分配的。 它们可能由new int分配，但它们也可以指向分配有new int[200]的数组中的元素，或者它们可能指向malloc的数据，或者它们可能指向mmap的缓冲区，或者它们可能指向 struct 元素，或者两个向量可能指向同一个int s... 等等vector不够聪明，无法判断你想用这些做什么，所以它不理会它们（此外，提供要删除的vector逻辑指向的元素会破坏非指针元素的向量，例如std::vector<int> ，因为您不能delete int ！）

您需要使用std::vector<int> ，或结合使用智能指针，例如std::vector<boost::shared_ptr<int> > 。 请注意，使用智能指针可能会增加开销； 使用 C++0x，您应该能够将std::vector<std::unique_ptr<int>>与std::move结合使用以避免这种开销。 Boost 也有指针向量，可以像你预期的那样释放指向的元素。

Answer 2

现在应该调用向量v的每个元素的析构函数

是的：存储在向量中的int*对象被销毁（这实际上是一个无操作）。 容器中的指针指向的对象不会被销毁。

考虑以下同样有效的程序：

{
    int x;
    std::vector<int*> v;
    v.push_back(&x);
}   // x cannot be delete'd because it isn't dynamically allocated.

您应该使用智能指针，如std::unique_ptr或shared_ptr这样您就不必担心 memory 管理（不要使用std::auto_ptr ；它与标准库容器不兼容，因为它不是真的可复制）。 如果您不使用智能指针，那么您需要自己销毁动态对象； 正确地做到这一点相当困难。

Answer 3

矢量的每个元素都是一个int * 。 当int *被销毁时，语言不会自动对其调用delete 。 换句话说，被销毁的是指针，而不是指针。

Answer 4

由于您使用的是new关键字，因此整数被分配在堆上而不是堆栈上。 换句话说，它们是动态分配的。 换句话说，你需要在它之后进行清理。

指针类型的“析构函数”是简单地删除该指针。 它不接触指针存储的位于 memory 地址的数据。 考虑以下示例：

int a = 5;
int* i = &a;
if (true)
{
   int* j = i;
} //j goes out of scope, should *i and a be deleted? no.

所以你需要在析构函数中这样做：

std::vector<int*>::iterator iter;
for (iter = v.begin(); iter != v.end(); iter++)
{
   delete *iter;
}