blocks|key|901535|text|是的，但是你需要一个functor：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|901536|struct+delete_ptr
{
++++template+<typename+T>
++++void+operator()(T*+pPtr)
++++{
++++++++delete+pPtr;
++++}
};

std::for_each(objs.begin(),+objs.end(),+delete_ptr());|code-block|syntax|javascript|901537|在C%2B%2B0x中，lambda可以帮助你就地创建函数器：|901538|std::for_each(objs.begin(),+objs.end(),+[](Obj*+pPtr){+delete+pPtr;+});|901539|901540|然而，面对异常，这是危险的。sbi+has+shown+a+solution.|offset|length|901541|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3505343/can-i-call-delete-on-a-vector-of-pointers-in-c-via-for-each-algorithm/3505412#3505412^0|0|0|0|0|0|E|P|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|12|8|@]|9|@$N|13|O|14|1|15]]|A|$]]|$1|P|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]]]

Yes, but you need a functor:

<pre><code>struct delete_ptr
{
 template &lt;typename T&gt;
 void operator()(T* pPtr)
 {
 delete pPtr;
 }
};

std::for_each(objs.begin(), objs.end(), delete_ptr());
</code></pre>

In C++0x, lambda's help you make functors in-place:

<pre><code>std::for_each(objs.begin(), objs.end(), [](Obj* pPtr){ delete pPtr; });
</code></pre>

<hr>

However, this is dangerous, in the face of exceptions. <a href="https://stackoverflow.com/questions/3505343/can-i-call-delete-on-a-vector-of-pointers-in-c-via-for-each-algorithm/3505412#3505412">sbi has shown a solution.</a>

blocks|key|899330|text|你的问题是delete不是一个函数，而是一个关键字，因此你不能接受它的地址。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|899331|在C%2B%2B0x中，将有一个std::default_delete类(由std::unique_ptr使用)，您可以使用它，或者正如每个人所说的那样，自己编写一个类将是微不足道的(如果您试图删除不完整的类型，则标准类也会引发编译错误)。|899332|#include+<vector>
#include+<algorithm>
#include+<memory>

int+main()
{
++++std::vector<int*>+vec;
++++std::for_each(vec.begin(),+vec.end(),+std::default_delete<int>());
}|code-block|syntax|javascript|899333|entityMap^0|5|6|0|C|J|Y|F|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

Your problem is that <code>delete</code> is not a function, but rather a keyword and as such you can't take it's address.

In C++0x, there will be a <code>std::default_delete</code> class (used by <code>std::unique_ptr</code>), which you could use, or - as everyone's saying - writing one yourself would be trivial (the standard one also raises a compile error, if you try to delete an incomplete type).

<pre><code>#include &lt;vector&gt;
#include &lt;algorithm&gt;
#include &lt;memory&gt;

int main()
{
 std::vector&lt;int*&gt; vec;
 std::for_each(vec.begin(), vec.end(), std::default_delete&lt;int&gt;());
}
</code></pre>

blocks|key|4173880|text|虽然您可以做到这一点(GMan+has+shown+a+solution)，但拥有带有指向所拥有资源的裸指针的容器是一种强烈的代码味道。例如，在此代码中：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4173881|++void+foo()
++{
++++std::vector<Obj+*>+bar;
++++fill(bar);
++++use(bar);
++++std::for_each(objs.begin(),+objs.end(),+delete_ptr());+//+as+GMan+suggests
++}|code-block|syntax|javascript|4173882|如果use()抛出，你会泄漏对象。|style|CODE|4173883|因此，最好使用智能指针：|4173884|std::vector<+std::shared_ptr<Obj>+>+bar;|4173885|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3505343/can-i-call-delete-on-a-vector-of-pointers-in-c-via-for-each-algorithm/3505366#3505366^0|B|P|0|0|0|2|5|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@$A|14|B|15|K|L]]|9|@]|C|$]]|$1|M|3|N|5|6|7|16|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|17|8|@]|9|@]|C|$G|H]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

While you can do this (<a href="https://stackoverflow.com/questions/3505343/can-i-call-delete-on-a-vector-of-pointers-in-c-via-for-each-algorithm/3505366#3505366">GMan has shown a solution</a>), having containers with naked pointers to owned resources is a strong code smell. For example, in this code: 

<pre><code> void foo()
 {
 std::vector&lt;Obj *&gt; bar;
 fill(bar);
 use(bar);
 std::for_each(objs.begin(), objs.end(), delete_ptr()); // as GMan suggests
 }
</code></pre>

if <code>use()</code> throws, you'll leak objects. 

So it's better to use smart pointers for this: 

<pre><code>std::vector&lt; std::shared_ptr&lt;Obj&gt; &gt; bar;
</code></pre>

blocks|key|901596|text|for_each需要函数指针或函数对象。对于内存释放，您可以尝试使用&::operator+delete，它将获取释放内存的函数的地址。但是，当您使用delete语句时，编译器会在调用operator+delete(void*)之前调用析构函数，因此cleanup实际上不是operator+delete(void*)函数的一部分。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|901597|使用函数器ala+GMan的答案。|901598|entityMap^0|0|8|Y|I|2K|M|3T|M|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

<code>for_each</code> needs a function pointer or function object. For memory deallocation you could try <code>&amp;::operator delete</code>, which would take the address of the function that deallocates memory. However, when you use the delete statement the compiler calls the destructor before calling <code>operator delete(void*)</code> so cleanup is actually not part of the <code>operator delete(void*)</code> function.

Use a functor ala GMan's answer.

blocks|key|901616|text|不完全是；for_each需要一个可以用()调用的函数或对象，而delete既不是函数也不是对象。您必须将其包装在一个函数(或函数对象)中，可能如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|901617|struct+Deleter
{
++++void+operator()(Obj*+obj)+{delete+obj;}
};

std::for_each(objs.begin(),+objs.end(),+Deleter());|code-block|syntax|javascript|901618|但是你应该非常小心地使用原始指针来管理对象的生命周期，特别是当你传递它们的时候。如果您从vector中删除它们，或者重新分配它们，或者清除vector，或者如果异常、中断或函数返回可能导致向量被销毁，则需要记住删除它们。一般来说，将资源管理和资源使用的职责分开总是更好的。|901619|最好使用对象的向量，除非Obj是一个多态基类，或者对象确实足够大或足够复杂，复制它们会对性能产生明显的影响。如果是这种情况(并且您已经对其进行了分析以确保确实是这种情况)，则应该考虑智能指针向量(shared_ptr，如果编译器支持，则为unique_ptr+)，或者Boost的ptr_vector。|901620|养成使用自动资源管理类的习惯将为您在未来省去很多麻烦。|901621|entityMap^0|5|8|K|2|W|6|0|0|18|6|1X|6|0|C|3|2Q|A|3B|A|3W|A|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1E|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|R|$]]

Not exactly; <code>for_each</code> requires a function or object that can be invoked with <code>()</code>, and <code>delete</code> is neither a function nor an object. You will have to wrap it up in a function (or function object), perhaps like:

<pre><code>struct Deleter
{
 void operator()(Obj* obj) {delete obj;}
};

std::for_each(objs.begin(), objs.end(), Deleter());
</code></pre>

But you should be very careful managing object lifetimes with raw pointers, especially if you're passing them around. You'll need to remember to delete them if you erase them from the <code>vector</code>, or reassign them, or if you clear the <code>vector</code>, or if an exception, break or function return might cause the vector to be destroyed. In general, it's always better to separate the responsibilities of resource management and resource usage.

You'd be better off with a vector of objects, unless <code>Obj</code> is a polymorphic base class, or the objects really are big or complicated enough that copying them will have a noticeable impact on performance. If that is the case (and you've profiled it to be sure that it's the case), you should consider a vector of smart pointers (<code>shared_ptr</code>, or <code>unique_ptr</code> if your compiler supports it), or Boost's <code>ptr_vector</code>.

Getting in the habit of using automatic resource management classes will save you a lot of headaches in the future.

blocks|key|1648311|text|您可以通过将shared_ptr存储在向量中或使用boost的ptr_vector+(参见http://www.boost.org/doc/libs/1_39_0/libs/ptr_container/doc/tutorial.html)来完全解决删除问题，而不是尝试解决删除问题。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1648312|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_39_0/libs/ptr_container/doc/tutorial.html^0|6|A|V|A|19|21|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Instead of trying to solve the deletion problem, you can make it go away completely by storing <code>shared_ptr</code>s in the vector, or by using boost's <code>ptr_vector</code> (see <a href="http://www.boost.org/doc/libs/1_39_0/libs/ptr_container/doc/tutorial.html" rel="nofollow noreferrer">http://www.boost.org/doc/libs/1_39_0/libs/ptr_container/doc/tutorial.html</a>).

blocks|key|2765807|text|是。用智能指针填充它并使用vector.clear()是最简单的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2765808|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes. Fill it with smart pointers and use vector.clear() is the easiest way.

Suppose I have a <code>std::vector&lt;Obj *&gt; objs</code> (for performance reasons I have pointers not actual <code>Obj</code>s).

I populate it with <code>obj.push_back(new Obj(...));</code> repeatedly.

After I am done, I have to <code>delete</code> the pushed-back elements. One way is to do this:

<pre><code>for (std::vector&lt;Obj *&gt;::iterator it = objs.begin(); it != objs.end(); ++it) {
 delete *it;
}
</code></pre>

However, I am interested if I can use <code>for_each</code> algorithm to do the same:

<pre><code>#include &lt;algorithm&gt;
...
for_each(objs.begin(), objs.end(), delete);
</code></pre>

What do you think?

Can I call `delete` on a vector of pointers in C++ via for_each <algorithm>?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

假设我有一个std::vector<Obj *> objs (出于性能原因，我有指针，而不是实际的Obj)。我反复地用obj.push_back(new Obj(...));填充它。完成后，我必须对推回的元素执行delete。一种方法是这样做：for (std::vector<Obj *>::iterator it =...

问可以通过for_each <algorithm>在C++中调用指针向量的`delete`吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问可以通过for_each <algorithm>在C++中调用指针向量的`delete`吗？EN