为了安全地清理 std::vector 或 std::list 的指针，你能想到的最短的 C++ 块是什么？ （假设你必须在指针上调用 delete？）
list<Foo*> foo_list;
我宁愿不使用 Boost 或用智能指针包装我的指针。
【问题讨论】：
对于std::list<T*> 使用：
while(!foo.empty()) delete foo.front(), foo.pop_front();
对于std::vector<T*> 使用：
while(!bar.empty()) delete bar.back(), bar.pop_back();
不知道为什么我在上面的std::list 中选择了front 而不是back。我想这是感觉它更快。但实际上两者都是恒定的时间:)。无论如何将其包装成一个函数并玩得开心：
template<typename Container>
void delete_them(Container& c) { while(!c.empty()) delete c.back(), c.pop_back(); }
【讨论】：
delete，以便释放内存。
既然我们在这里挑战...“最短的 C++ 块”
static bool deleteAll( Foo * theElement ) { delete theElement; return true; }
foo_list . remove_if ( deleteAll );
我认为我们可以相信提出 STL 的人拥有高效的算法。为什么要重新发明轮子？
【讨论】：
foo_list.remove_if([](Foo *theElement){delete theElement; return true;});
for(list<Foo*>::const_iterator it = foo_list.begin(); it != foo_list.end(); ++it)
{
delete *it;
}
foo_list.clear();
【讨论】：
如果你允许 C++11，你可以做一个非常简短的 Douglas Leeder 的回答：
for(auto &it:foo_list) delete it; foo_list.clear();
【讨论】：
依赖容器外的代码来删除你的指针真的很危险。例如，当容器因抛出异常而销毁时会发生什么？
我知道你说过你不喜欢 boost，但请考虑boost pointer containers。
【讨论】：
template< typename T >
struct delete_ptr : public std::unary_function<T,bool>
{
bool operator()(T*pT) const { delete pT; return true; }
};
std::for_each(foo_list.begin(), foo_list.end(), delete_ptr<Foo>());
【讨论】：
为了简洁起见，我不确定函子方法是否会胜出。
for( list<Foo*>::iterator i = foo_list.begin(); i != foo_list.end(); ++i )
delete *i;
不过，我通常建议不要这样做。通常，将指针包装在智能指针中或使用专门的指针容器会更加健壮。有很多方法可以从列表中删除项目（erase、clear 的各种风格、列表的破坏、通过迭代器分配到列表中，等等）。你能保证全部抓到吗？
【讨论】：
begin()、end()、iterator::operator!=、iterator::operator*、iterator::operator++。令人惊讶的是，这种依赖是不安全的：stackoverflow.com/questions/7902452/…
当您的列表使用 RAII 超出范围或调用 list::clear() 时，以下 hack 会删除指针。
template <typename T>
class Deleter {
public:
Deleter(T* pointer) : pointer_(pointer) { }
Deleter(const Deleter& deleter) {
Deleter* d = const_cast<Deleter*>(&deleter);
pointer_ = d->pointer_;
d->pointer_ = 0;
}
~Deleter() { delete pointer_; }
T* pointer_;
};
例子：
std::list<Deleter<Foo> > foo_list;
foo_list.push_back(new Foo());
foo_list.clear();
【讨论】：
至少对于一个列表，迭代和删除，然后在最后调用 clear 有点无效，因为它涉及遍历列表两次，而实际上你只需要执行一次。这里有一个更好的方法：
for (list<Foo*>::iterator i = foo_list.begin(), e = foo_list.end(); i != e; )
{
list<Foo*>::iterator tmp(i++);
delete *tmp;
foo_list.erase(tmp);
}
也就是说，您的编译器可能足够聪明，可以循环组合两者，这取决于 list::clear 的实现方式。
【讨论】：
【讨论】：
for(list<Foo*>::const_iterator it = foo_list.begin(); it != foo_list.end(); it++)
{
delete *it;
}
foo_list.clear();
您不想这样做有一个小原因 - 您实际上是在对列表进行两次迭代。
std::list::clear 的复杂度是线性的；它在循环中一次删除和销毁一个元素。
考虑到上述情况，我认为最简单易读的解决方案是：
while(!foo_list.empty())
{
delete foo_list.front();
foo_list.pop_front();
}
【讨论】：
C++11 起：
std::vector<Type*> v;
...
std::for_each(v.begin(), v.end(), std::default_delete<Type>());
或者，如果您正在编写模板代码并希望避免指定具体类型：
std::for_each(v.begin(), v.end(),
std::default_delete<std::remove_pointer<decltype(v)::value_type>::type>());
其中（C++14 起）可以缩写为：
std::for_each(v.begin(), v.end(),
std::default_delete<std::remove_pointer_t<decltype(v)::value_type>>());
【讨论】：
void remove(Foo* foo) { delete foo; }
....
for_each( foo_list.begin(), foo_list.end(), remove );
【讨论】：
delete foo 已经检查了foo 是否为nullptr，是吗？
for (list<Foo*>::const_iterator i = foo_list.begin(), e = foo_list.end(); i != e; ++i)
delete *i;
foo_list.clear();
【讨论】：
这似乎是最干净的 imo，但您的 c++ 版本必须支持这种类型的迭代（我相信包括或在 c++0x 之前的任何东西都可以工作）：
for (Object *i : container) delete i;
container.clear();
【讨论】：