74

我正在使用指向对象的指针向量。这些对象是从基类派生的，并且是动态分配和存储的。

例如，我有类似的东西：

vector<Enemy*> Enemies;

我将从 Enemy 类派生，然后为派生类动态分配内存，如下所示：

enemies.push_back(new Monster());

为了避免内存泄漏和其他问题，我需要注意哪些事项？

4

4 回答 4

161

std::vector将像往常一样为您管理内存，但此内存将是指针，而不是对象。

这意味着一旦您的向量超出范围，您的类将丢失在内存中。例如：

#include <vector>

struct base
{
    virtual ~base() {}
};

struct derived : base {};

typedef std::vector<base*> container;

void foo()
{
    container c;

    for (unsigned i = 0; i < 100; ++i)
        c.push_back(new derived());

} // leaks here! frees the pointers, doesn't delete them (nor should it)

int main()
{
    foo();
}

您需要做的是确保在向量超出范围之前删除所有对象：

#include <algorithm>
#include <vector>

struct base
{
    virtual ~base() {}
};

struct derived : base {};

typedef std::vector<base*> container;

template <typename T>
void delete_pointed_to(T* const ptr)
{
    delete ptr;
}

void foo()
{
    container c;

    for (unsigned i = 0; i < 100; ++i)
        c.push_back(new derived());

    // free memory
    std::for_each(c.begin(), c.end(), delete_pointed_to<base>);
}

int main()
{
    foo();
}

但是，这很难维护，因为我们必须记住执行一些操作。更重要的是，如果在元素分配和释放循环之间发生异常，释放循环将永远不会运行，并且无论如何您都会遇到内存泄漏！这称为异常安全，它是释放需要自动完成的一个关键原因。

如果指针自己删除会更好。这些被称为智能指针，标准库提供std::unique_ptr和std::shared_ptr.

std::unique_ptr表示指向某个资源的唯一（非共享、单一所有者）指针。这应该是您的默认智能指针，并且可以完全替代任何原始指针的使用。

auto myresource = /*std::*/make_unique<derived>(); // won't leak, frees itself

std::make_unique由于疏忽而从 C++11 标准中丢失，但您可以自己制作一个。要直接创建一个unique_ptr（make_unique如果可以，不推荐），请执行以下操作：

std::unique_ptr<derived> myresource(new derived());

唯一指针只有移动语义；它们不能被复制：

auto x = myresource; // error, cannot copy
auto y = std::move(myresource); // okay, now myresource is empty

这就是我们在容器中使用它所需的全部内容：

#include <memory>
#include <vector>

struct base
{
    virtual ~base() {}
};

struct derived : base {};

typedef std::vector<std::unique_ptr<base>> container;

void foo()
{
    container c;

    for (unsigned i = 0; i < 100; ++i)
        c.push_back(make_unique<derived>());

} // all automatically freed here

int main()
{
    foo();
}

shared_ptr具有引用计数复制语义；它允许多个所有者共享对象。它跟踪一个对象存在多少shared_ptr个 s，当最后一个不存在时（该计数变为零），它释放指针。复制只是增加了引用计数（并以更低、几乎免费的成本转移所有权）。您可以使用std::make_shared（或直接如上所示，但由于shared_ptr必须在内部进行分配，因此通常更有效，并且在技术上更安全地使用make_shared）。

#include <memory>
#include <vector>

struct base
{
    virtual ~base() {}
};

struct derived : base {};

typedef std::vector<std::shared_ptr<base>> container;

void foo()
{
    container c;

    for (unsigned i = 0; i < 100; ++i)
        c.push_back(std::make_shared<derived>());

} // all automatically freed here

int main()
{
    foo();
}

请记住，您通常希望将std::unique_ptr其用作默认值，因为它更轻量级。此外，std::shared_ptr可以由 a 构建std::unique_ptr（但反之亦然），因此可以从小处着手。

或者，您可以使用创建的容器来存储指向对象的指针，例如boost::ptr_container：

#include <boost/ptr_container/ptr_vector.hpp>

struct base
{
    virtual ~base() {}
};

struct derived : base {};

// hold pointers, specially
typedef boost::ptr_vector<base> container;

void foo()
{
    container c;

    for (int i = 0; i < 100; ++i)
        c.push_back(new Derived());

} // all automatically freed here

int main()
{
    foo();
}

虽然boost::ptr_vector<T>在 C++03 中有明显的用途，但我现在不能谈论相关性，因为我们可以使用std::vector<std::unique_ptr<T>>可能很少甚至没有可比开销，但这种说法应该经过测试。

无论如何，永远不要在你的代码中明确地释放东西。总结一下以确保自动处理资源管理。您的代码中不应该有原始的拥有指针。

作为游戏中的默认设置，我可能会选择std::vector<std::shared_ptr<T>>. 无论如何，我们希望共享，它足够快，直到配置文件另有说明，它是安全的，并且易于使用。

于 2009-09-01T08:24:44.563 回答
10

使用的问题vector<T*>是，每当向量意外超出范围时（比如抛出异常时），向量会在你自己之后清理，但这只会释放它为保存指针而管理的内存，而不是你分配的内存对于指针所指的内容。所以GMan 的delete_pointed_to功能价值有限，因为它只有在没有问题的情况下才有效。

您需要做的是使用智能指针：

vector< std::tr1::shared_ptr<Enemy> > Enemies;

（如果您的标准库没有 TR1，请boost::shared_ptr改用。）除了非常罕见的极端情况（循环引用）之外，这只是消除了对象生命周期的麻烦。

编辑：请注意，GMan 在他的详细回答中也提到了这一点。

于 2009-09-01T08:41:04.873 回答
9

我假设以下：

  1. 你有一个像 vector< base* > 这样的向量
  2. 在堆上分配对象后，您将指针推向此向量
  3. 您想要对这个向量执行一个 push_back 派生*指针。

我想到以下几点：

  1. Vector不会释放指针指向的对象的内存。你必须自己删除它。
  2. 没有特定于向量的，但基类析构函数应该是虚拟的。
  3. vector< base* > 和 vector< derived* > 是两种完全不同的类型。
于 2009-09-01T08:04:09.113 回答
-1

需要非常小心的一件事是，如果有两个 Monster() DERIVED 对象，其内容的值相同。假设您想从向量中删除 DUPLICATE Monster 对象（指向 DERIVED Monster 对象的 BASE 类指针）。如果您使用标准习语来删除重复项（排序、唯一、擦除：参见 LINK #2]，您将遇到内存泄漏问题和/或重复删除问题，可能导致 SEGMENTATION VOIOLATIONS（我个人在LINUX机器）。

std::unique() 的问题是向量末尾的 [duplicatePosition,end) 范围 [包括，不包括) 中的重复项未定义为 ?。可能发生的情况是那些未定义的 ((?) 项可能是多余的重复项或缺少的重复项。

问题是 std::unique() 不适合正确处理指针向量。原因是 std::unique 将唯一性从向量“向下”的末尾复制到向量的开头。对于普通对象的向量，这会调用 COPY CTOR，如果 COPY CTOR 写入正确，则不会出现内存泄漏问题。但是当它是一个指针向量时，除了“按位复制”之外没有 COPY CTOR，因此指针本身被简单地复制。

除了使用智能指针之外，还有其他方法可以解决这些内存泄漏。将您自己的 std::unique() 稍作修改版本编写为“your_company::unique()”的一种方法。基本技巧是，您将交换两个元素，而不是复制一个元素。而且您必须确保不是比较两个指针，而是调用 BinaryPredicate 跟随两个指向对象本身的指针，并比较这两个“Monster”派生对象的内容。

1）@SEE_ALSO： http ://www.cplusplus.com/reference/algorithm/unique/

2）@SEE_ALSO： 删除重复项和对向量进行排序的最有效方法是什么？

第二个链接写得很好，适用于 std::vector 但有内存泄漏、重复释放（有时导致 SEGMENTATION 违规）对于 std::vector

3）@SEE_ALSO：valgrind（1）。LINUX 上的这个“内存泄漏”工具的发现令人惊叹！我强烈推荐使用它！

我希望在以后的帖子中发布一个不错的“my_company::unique()”版本。现在，它并不完美，因为我希望具有 BinaryPredicate 的 3-arg 版本可以无缝地用于函数指针或 FUNCTOR，并且我在正确处理两者时遇到了一些问题。如果我无法解决这些问题，我会发布我所拥有的，并让社区尝试改进我目前所做的工作。

于 2013-02-09T06:37:40.563 回答