我正在使用指向对象的指针向量。这些对象派生自基类，并且正在动态分配和存储。
例如，我有类似的东西：
vector<Enemy*> Enemies;
我将从Enemy类派生，然后为派生类动态分配内存，如下所示：
enemies.push_back(new Monster());
为避免内存泄漏和其他问题，我需要注意哪些事项？
答案 0 :(得分：142)
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，但您可以自己制作一个。要直接创建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，当最后一个停止存在时（该计数变为零），它释放指针。复制只会增加引用计数（并以较低的，几乎免费的成本移动转移所有权）。您可以使用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可以由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>>。无论如何，我们期待共享，它的速度足够快，直到分析说不然，它是安全的，而且它很容易使用。
答案 1 :(得分：9)
我假设如下：
我想到了以下事情：
答案 2 :(得分：9)
使用vector<T*>的麻烦在于，每当向量意外地超出范围时（比如抛出异常时），向量会自行清理，但这只会释放它管理的内存以保存指针，而不是您为指针所指的内存分配的内存。所以GMan's delete_pointed_to function价值有限，因为它只在没有出错的情况下才有效。
您需要做的是使用智能指针：
vector< std::tr1::shared_ptr<Enemy> > Enemies;
（如果您的std lib没有TR1，请改用boost::shared_ptr。）
除了非常罕见的极端情况（循环引用）之外，这简单地消除了对象生存期的麻烦。
编辑：请注意，GMan在他的详细答案中也提到了这一点。
答案 3 :(得分：-1)
要注意的一件事是，如果有两个Monster（）DERIVED对象，其内容值相同。假设您要从向量中删除DUPLICATE Monster对象（BASE类指向DERIVED Monster对象）。如果您使用标准惯用法删除重复项（排序，唯一，擦除：请参阅链接＃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：What's the most efficient way to erase duplicates and sort a vector?
第二个链接写得非常好，并且适用于std :: vector但是有std :: vector
的内存泄漏，重复释放（有时会导致SEGMENTATION违规）3）@SEE_ALSO：valgrind（1）。 LINUX上的“内存泄漏”工具在它能找到的东西中是惊人的！我强烈建议使用它！
我希望在以后的帖子中发布一个很好的版本“my_company :: unique（）”。现在，它并不完美，因为我希望具有BinaryPredicate的3-arg版本可以无缝地用于函数指针或FUNCTOR，并且我在处理这两个问题时遇到了一些问题。如果我无法解决这些问题，我会发布我所拥有的内容，并让社区改进我到目前为止所做的工作。