blocks|key|1685851|text|既然我们要在这里接受挑战。“最短的C%2B%2B块”|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1685852|static+bool+deleteAll(+Foo+*+theElement+)+{+delete+theElement;+return+true;+}

foo_list+.+remove_if+(+deleteAll+);|code-block|syntax|javascript|1685853|我认为我们可以相信那些提出STL的人拥有高效的算法。为什么要重新发明轮子呢？|1685854|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Since we are throwing down the gauntlet here... "Shortest chunk of C++"

<pre><code>static bool deleteAll( Foo * theElement ) { delete theElement; return true; }

foo_list . remove_if ( deleteAll );
</code></pre>

I think we can trust the folks who came up with STL to have efficient algorithms. Why reinvent the wheel?

blocks|key|1470304|text|对于std::list<T*>使用：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1470305|while(!foo.empty())+delete+foo.front(),+foo.pop_front();|code-block|syntax|javascript|1470306|对于std::vector<T*>使用：|1470307|while(!bar.empty())+delete+bar.back(),+bar.pop_back();|1470308|不知道为什么我在上面的std::list中选择了front而不是back。我猜是因为感觉它更快了。但实际上两者都是常量时间:)。无论如何，将它包装到一个函数中，并享受乐趣：|1470309|template<typename+Container>
void+delete_them(Container&+c)+{+while(!c.empty())+delete+c.back(),+c.pop_back();+}|1470310|entityMap^0|2|D|0|0|2|F|0|0|B|9|O|5|W|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|T|$]]

For <code>std::list&lt;T*&gt;</code> use:

<pre><code>while(!foo.empty()) delete foo.front(), foo.pop_front();
</code></pre>

For <code>std::vector&lt;T*&gt;</code> use:

<pre><code>while(!bar.empty()) delete bar.back(), bar.pop_back();
</code></pre>

Not sure why i took <code>front</code> instead of <code>back</code> for <code>std::list</code> above. I guess it's the feeling that it's faster. But actually both are constant time :). Anyway wrap it into a function and have fun:

<pre><code>template&lt;typename Container&gt;
void delete_them(Container&amp; c) { while(!c.empty()) delete c.back(), c.pop_back(); }
</code></pre>

blocks|key|1685363|text|for(list<Foo*>::const_iterator+it+=+foo_list.begin();+it+!=+foo_list.end();+%2B%2Bit)
{
++++delete+*it;
}+
foo_list.clear();|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1685364|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>for(list&lt;Foo*&gt;::const_iterator it = foo_list.begin(); it != foo_list.end(); ++it)
{
 delete *it;
} 
foo_list.clear();
</code></pre>

blocks|key|1686097|text|如果你允许C%2B%2B11，你可以做一个非常简短的Douglas+Leeder的回答：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1686098|for(auto+&it:foo_list)+delete+it;+foo_list.clear();|code-block|syntax|javascript|1686099|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you allow C++11, you can do a very short version of Douglas Leeder's answer:

<pre><code>for(auto &amp;it:foo_list) delete it; foo_list.clear();
</code></pre>

blocks|key|1685648|text|依赖容器外的代码来删除指针是非常危险的。例如，当容器由于抛出的异常而被销毁时会发生什么？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1685649|我知道你说过你不喜欢boost，但请考虑一下boost+pointer+containers。|offset|length|1685650|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_37_0/libs/ptr_container/doc/ptr_container.html^0|0|M|O|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

It's really dangerous to rely on code outside of the container to delete your pointers. What happens when the container is destroyed due to a thrown exception, for example?

I know you said you don't like boost, but please consider the <a href="http://www.boost.org/doc/libs/1_37_0/libs/ptr_container/doc/ptr_container.html" rel="noreferrer">boost pointer containers</a>.

blocks|key|1470153|text|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>());|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1470154|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>template&lt; typename T &gt;
struct delete_ptr : public std::unary_function&lt;T,bool&gt;
{
 bool operator()(T*pT) const { delete pT; return true; }
};

std::for_each(foo_list.begin(), foo_list.end(), delete_ptr&lt;Foo&gt;());
</code></pre>

blocks|key|1470232|text|我不确定函数式方法在这里是否因为简洁而胜出。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1470233|for(+list<Foo*>::iterator+i+=+foo_list.begin();+i+!=+foo_list.end();+%2B%2Bi+)
++++delete+*i;|code-block|syntax|javascript|1470234|不过，我通常会建议不要这么做。通常，将指针包装在智能指针中或使用专业指针容器会更健壮。有很多方法可以从列表中删除项(各种风格的erase、clear、销毁列表、通过迭代器赋值到列表中，等等)。你能保证把他们都抓到吗？|offset|length|style|CODE|1470235|entityMap^0|0|0|1R|5|1X|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

I'm not sure that the functor approach wins for brevity here.

<pre><code>for( list&lt;Foo*&gt;::iterator i = foo_list.begin(); i != foo_list.end(); ++i )
 delete *i;
</code></pre>

I'd usually advise against this, though. Wrapping the pointers in smart pointers or using a specialist pointer container is, in general, going to be more robust. There are lots of ways that items can be removed from a list ( various flavours of <code>erase</code>, <code>clear</code>, destruction of the list, assignment via an iterator into the list, etc. ). Can you guarantee to catch them all?

blocks|key|1686015|text|当您的list使用RAII或调用list::clear()超出作用域时，下面的hack将删除指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1686016|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_;
};|code-block|syntax|javascript|1686017|示例：|1686018|std::list<Deleter<Foo>+>+foo_list;
foo_list.push_back(new+Foo());
foo_list.clear();|1686019|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The following hack deletes the pointers when your list goes out of scope using RAII or if you call list::clear().

<pre><code>template &lt;typename T&gt;
class Deleter {
public:
 Deleter(T* pointer) : pointer_(pointer) { }
 Deleter(const Deleter&amp; deleter) {
 Deleter* d = const_cast&lt;Deleter*&gt;(&amp;deleter);
 pointer_ = d-&gt;pointer_;
 d-&gt;pointer_ = 0;
 }
 ~Deleter() { delete pointer_; }
 T* pointer_;
};
</code></pre>

Example:

<pre><code>std::list&lt;Deleter&lt;Foo&gt; &gt; foo_list;
foo_list.push_back(new Foo());
foo_list.clear();
</code></pre>

blocks|key|1685724|text|至少对于一个列表，迭代和删除，然后在最后调用clear是有点低效的，因为它涉及到遍历列表两次，而你实际上只需要做一次。这里有一个更好的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1685725|for+(list<Foo*>::iterator+i+=+foo_list.begin(),+e+=+foo_list.end();+i+!=+e;+)
{
++++list<Foo*>::iterator+tmp(i%2B%2B);
++++delete+*tmp;
++++foo_list.erase(tmp);
}|code-block|syntax|javascript|1685726|也就是说，根据list::clear的实现方式，您的编译器可能足够智能，以循环方式将两者组合在一起。|1685727|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

At least for a list, iterating and deleting, then calling clear at the end is a bit inneficient since it involves traversing the list twice, when you really only have to do it once. Here is a little better way:

<pre><code>for (list&lt;Foo*&gt;::iterator i = foo_list.begin(), e = foo_list.end(); i != e; )
{
 list&lt;Foo*&gt;::iterator tmp(i++);
 delete *tmp;
 foo_list.erase(tmp);
}
</code></pre>

That said, your compiler may be smart enough to loop combine the two anyways, depending on how list::clear is implemented.

blocks|key|1470701|text|实际上，我相信STD库以allocator+class的形式提供了一种管理内存的直接方法|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1470702|您可以扩展基本分配器的deallocate()方法，以自动删除任何容器的成员。|1470703|我/认为/这就是它想要的类型。|1470704|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cplusplus.com/reference/std/memory/allocator/^0|C|F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

Actually, I believe the STD library provides a direct method of managing memory in the form of the <a href="http://www.cplusplus.com/reference/std/memory/allocator/" rel="nofollow noreferrer">allocator class</a>

You can extend the basic allocator's deallocate() method to automatically delete the members of any container.

I /think/ this is the type of thing it's intended for.

blocks|key|1686160|text|for(list<Foo*>::const_iterator+it+=+foo_list.begin();+it+!=+foo_list.end();+it%2B%2B)
{
++++delete+*it;
}+
foo_list.clear();|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1686161|您不想这样做有一个小原因--您有效地迭代了列表两次。|unstyled|1686162|std::list<>::clear的复杂性是线性的；它在循环中一次删除和销毁一个元素。|1686163|综合以上几点，我认为最简单的解决方案是：|1686164|while(!foo_list.empty())
{
++++delete+foo_list.front();
++++foo_list.pop_front();
}|1686165|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>for(list&lt;Foo*&gt;::const_iterator it = foo_list.begin(); it != foo_list.end(); it++)
{
 delete *it;
} 
foo_list.clear();
</code></pre>

There's a small reason why you would not want to do this - you're effectively iterating over the list twice.

std::list&lt;>::clear is linear in complexity; it removes and destroys one element at a time within a loop.

Taking the above into consideration the simplest to read solution in my opinion is:

<pre><code>while(!foo_list.empty())
{
 delete foo_list.front();
 foo_list.pop_front();
}
</code></pre>

blocks|key|1686217|text|从C%2B%2B11开始：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1686218|std::vector<Type*>+v;
...
std::for_each(v.begin(),+v.end(),+std::default_delete<Type>());|code-block|syntax|javascript|1686219|或者，如果您正在编写模板化代码，并且希望避免指定具体的类型：|1686220|std::for_each(v.begin(),+v.end(),
++++std::default_delete<std::remove_pointer<decltype(v)::value_type>::type>());|1686221|它(从C%2B%2B14开始)可以缩写为：|1686222|std::for_each(v.begin(),+v.end(),
++++std::default_delete<std::remove_pointer_t<decltype(v)::value_type>>());|1686223|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Since C++11:

<pre><code>std::vector&lt;Type*&gt; v;
...
std::for_each(v.begin(), v.end(), std::default_delete&lt;Type&gt;());
</code></pre>

Or, if you are writing templated code and want to avoid specifying a concrete type:

<pre><code>std::for_each(v.begin(), v.end(),
 std::default_delete&lt;std::remove_pointer&lt;decltype(v)::value_type&gt;::type&gt;());
</code></pre>

Which (since C++14) can be shortened as:

<pre><code>std::for_each(v.begin(), v.end(),
 std::default_delete&lt;std::remove_pointer_t&lt;decltype(v)::value_type&gt;&gt;());
</code></pre>

blocks|key|1470791|text|void+remove(Foo*+foo)+{+delete+foo;+}
....
for_each(+foo_list.begin(),+foo_list.end(),+remove+);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1470792|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>void remove(Foo* foo) { delete foo; }
....
for_each( foo_list.begin(), foo_list.end(), remove );
</code></pre>

blocks|key|1685471|text|for+(list<Foo*>::const_iterator+i+=+foo_list.begin(),+e+=+foo_list.end();+i+!=+e;+%2B%2Bi)
++++delete+*i;
foo_list.clear();|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1685472|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>for (list&lt;Foo*&gt;::const_iterator i = foo_list.begin(), e = foo_list.end(); i != e; ++i)
 delete *i;
foo_list.clear();
</code></pre>

blocks|key|1686294|text|这似乎是最干净的imo，但是你的c%2B%2B版本必须支持这种迭代(我相信包括c%2B%2B0x或之前的任何东西都可以)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1686295|for+(Object+*i+:+container)+delete+i;++++
container.clear();|code-block|syntax|javascript|1686296|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This seems cleanest imo, but your c++ version must support this type of iteration (I believe anything including or ahead of c++0x will work):

<pre><code>for (Object *i : container) delete i; 
container.clear();
</code></pre>

What is the shortest chunk of C++ you can come up with to safely clean up a <code>std::vector</code> or <code>std::list</code> of pointers? (assuming you have to call delete on the pointers?)
<pre><code>list&lt;Foo*&gt; foo_list;
</code></pre>
I'd rather not use Boost or wrap my pointers with smart pointers.

Cleaning up an STL list/vector of pointers

你能想出的安全清理std::vector或std::list指针的最短的C++块是什么？(假设您必须在指针上调用delete？)list<Foo*> foo_list;我不想使用Boost或者用智能指针包装我的指针。

问清理STL指针列表/向量
EN

回答 15

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问清理STL指针列表/向量EN

回答 15

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问清理STL指针列表/向量
EN