blocks|key|3013713|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3013714|Yes|ordered-list-item|3013715|Vectors是使用模板内存分配器实现的，模板内存分配器负责为您管理内存，因此它们有些特殊。但作为一般经验法则，由于堆栈和堆分配之间的差异，您不必对未使用new关键字声明的变量调用delete。如果在堆上分配了内容，则必须将其删除(释放)以防止内存泄漏。|offset|length|style|CODE|3013716|No。在迭代所有元素时，必须显式调用delete+myVec[index]。|3013717|3013718|例如：|3013719|for(int+i+=+0;+i+<+myVec.size();+%2B%2Bi)
+++delete+myVec[i];|code-block|syntax|javascript|3013720|话虽如此，如果你打算在向量中存储指针，我强烈建议使用boost::ptr_vector，它会自动处理删除操作。|3013721|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_44_0/libs/ptr_container/doc/ptr_vector.html^0|0|0|25|3|2I|6|0|I|J|0|0|0|0|Q|H|Q|H|0|0^^$0|@$1|2|3|-4|4|5|6|13|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|14|7|@]|8|@]|9|$]]|$1|D|3|E|4|C|6|15|7|@$F|16|G|17|H|I]|$F|18|G|19|H|I]]|8|@]|9|$]]|$1|J|3|K|4|C|6|1A|7|@$F|1B|G|1C|H|I]]|8|@]|9|$]]|$1|L|3|-4|4|5|6|1D|7|@]|8|@]|9|$]]|$1|M|3|N|4|5|6|1E|7|@]|8|@]|9|$]]|$1|O|3|P|4|Q|6|1F|7|@]|8|@]|9|$R|S]]|$1|T|3|U|4|5|6|1G|7|@$F|1H|G|1I|H|I]]|8|@$F|1J|G|1K|1|1L]]|9|$]]|$1|V|3|-4|4|5|6|1M|7|@]|8|@]|9|$]]]|W|$X|$4|Y|Z|10|9|$11|12]]]]

<ol>
<li>Yes</li>
<li>Vectors are implemented using template memory allocators that take care of the memory management for you, so they are somewhat special. But as a general rule of thumb, you don't have to call <code>delete</code> on variables that aren't declared with the <code>new</code> keyword because of the difference between stack and heap allocation. If stuff is allocated on the heap, it must be deleted (freed) to prevent memory leaks.</li>
<li>No. You explicitly have to call <code>delete myVec[index]</code> as you iterate over all elements.</li>
</ol>

Ex:

<pre><code>for(int i = 0; i &lt; myVec.size(); ++i)
 delete myVec[i];
</code></pre>

With that said, if you're planning on storing pointers in a vector, I strongly suggest using <a href="http://www.boost.org/doc/libs/1_44_0/libs/ptr_container/doc/ptr_vector.html" rel="noreferrer"><code>boost::ptr_vector</code></a> which automatically takes care of the deletion.

blocks|key|3227845|text|如果您有权访问C%2B%2B0x，也可以使用std::unique_ptr。它取代了不能在容器中使用的过时std::auto_ptr。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3227846|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|$]]

You can also use std::unique_ptr if you have access to C++0x. It replaces the deprecated std::auto_ptr that couldn't be used in containers.

blocks|key|3013754|text|您使用new分配的所有内容都必须在以后的delete中使用。没有使用new显式分配的对象不应该使用delete。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3013755|如果您不想手动管理对象，但希望向量“拥有”它们，按值存储对象可能比存储指向它们的指针更好。所以你可以用std::vector<SomeClass>代替std::vector<SomeClass*>。|3013756|entityMap^0|3|3|K|6|Y|3|1D|6|0|1F|M|23|N|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|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|I|$]]

Everything you allocate with <code>new</code> you have to <code>delete</code> later on. Objects that you don't explicitly allocate with <code>new</code> shouldn't you <code>delete</code>.

If you don't want to manage the objects manually but want the vector to "own" them, it might be better to store the objects by value instead of storing pointers to them. So instead of <code>std::vector&lt;SomeClass*&gt;</code> you could use <code>std::vector&lt;SomeClass&gt;</code>.

blocks|key|3013789|text|删除是真的吗?当我完成向量后，我必须遍历它，并在每个指针上调用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3013790|？|blockquote|3013791|3013792|3013793|嗯，你不需要手动循环，你也可以使用算法：|3013794|#include+<vector>
#include+<algorithm>
#include+<memory>

int+main()
{
++++std::vector<Base*>+vec;
++++vec.push_back(new+Derived());
++++vec.push_back(new+Derived());
++++vec.push_back(new+Derived());

++++//+...

++++std::for_each(vec.begin(),+vec.end(),+std::default_delete<Base>());
}|code-block|syntax|javascript|3013795|如果你没有C%2B%2B0x编译器，你可以使用boost：|3013796|#include+<boost/lambda/lambda.hpp>
#include+<boost/lambda/construct.hpp>

std::for_each(vec.begin(),+vec.end(),+boost::lambda::delete_ptr());|3013797|或者，您可以编写自己的functor：|3013798|struct+delete_ptr
{
++++template+<class+T>
++++void+operator()(T*+p)
++++{
++++++++delete+p;
++++}
};

std::for_each(vec.begin(),+vec.end(),+delete_ptr());|3013799|entityMap^0|0|0|0|0|0|0|0|0|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|$]]|$1|E|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|11|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|12|8|@]|9|@]|A|$L|M]]|$1|N|3|O|5|6|7|13|8|@]|9|@]|A|$]]|$1|P|3|Q|5|K|7|14|8|@]|9|@]|A|$L|M]]|$1|R|3|S|5|6|7|15|8|@]|9|@]|A|$]]|$1|T|3|U|5|K|7|16|8|@]|9|@]|A|$L|M]]|$1|V|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|W|$]]

<blockquote>
 Is it true that when I am done with the vector I must loop through it and call delete on each pointer?
</blockquote>

Well, you don't have to loop by hand, you can also use an algorithm:

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

int main()
{
 std::vector&lt;Base*&gt; vec;
 vec.push_back(new Derived());
 vec.push_back(new Derived());
 vec.push_back(new Derived());

 // ...

 std::for_each(vec.begin(), vec.end(), std::default_delete&lt;Base&gt;());
}
</code></pre>

If you don't have a C++0x compiler, you can use boost:

<pre><code>#include &lt;boost/lambda/lambda.hpp&gt;
#include &lt;boost/lambda/construct.hpp&gt;

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

Or you can write your own functor:

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

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

blocks|key|293317|text|作为David+Titarenco提到的boost::ptr_vector的替代方案，您可以轻松地修改std::vector，以便在删除时自动释放包含指针的内存：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|293318|template<class+T>
class+Group+:+public+std::vector<T>
{
public:
++++virtual+~Group()+{};
};

template<class+T>
class+Group<T+*>+:+public+std::vector<T+*>
{
public:
++++virtual+~Group()
++++{
++++++++std::vector<T+*>::reverse_iterator+it;
++++++++for+(it+=+this->rbegin();+it+!=+this->rend();+%2B%2Bit)
++++++++++++delete+*it;
++++}
};|code-block|syntax|javascript|293319|std::vector提供的所有功能都是继承的，因此您可以使用相同的方式添加项：|293320|Group<Foo+*>+*bar+=+new+Group<Foo+*>();
bar->push_back(new+Foo());
bar->push_back(new+DerivedFoo());

//+Deleting+the+Group+will+free+all+memory+allocated+by+contained+pointers
delete+bar;|293321|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_44_0/libs/ptr_container/doc/ptr_vector.html^0|K|H|K|H|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

As an alternative to <a href="http://www.boost.org/doc/libs/1_44_0/libs/ptr_container/doc/ptr_vector.html" rel="nofollow"><code>boost::ptr_vector</code></a> as mentioned by David Titarenco, you can easily modify std::vector to automatically free memory for containing pointers on deletion:

<pre><code>template&lt;class T&gt;
class Group : public std::vector&lt;T&gt;
{
public:
 virtual ~Group() {};
};

template&lt;class T&gt;
class Group&lt;T *&gt; : public std::vector&lt;T *&gt;
{
public:
 virtual ~Group()
 {
 std::vector&lt;T *&gt;::reverse_iterator it;
 for (it = this-&gt;rbegin(); it != this-&gt;rend(); ++it)
 delete *it;
 }
};
</code></pre>

All functionality provided by std::vector is inherited so you would add items the same way:

<pre><code>Group&lt;Foo *&gt; *bar = new Group&lt;Foo *&gt;();
bar-&gt;push_back(new Foo());
bar-&gt;push_back(new DerivedFoo());

// Deleting the Group will free all memory allocated by contained pointers
delete bar;
</code></pre>

I have a vector that I fill with pointers to objects. I am trying to learn good memory management, and have a few general questions:

<ol>
<li>Is it true that when I am done with the vector, I must loop through it and call delete on each pointer?</li>
<li>Why don't I have to call delete on the vector or any other variable I declare without the new statement, but delete must be called on pointers?</li>
<li>Does C++ handle freeing the pointers' memory for me if the vector is declared in a function which returns (causing the vector to go out of scope)?</li>
</ol>

What do I need to do before deleting elements in a vector of pointers to dynamically allocated objects?

内存管理

编译器

容器

我有一个向量，我用指向对象的指针填充。我正在努力学习良好的内存管理，并有几个一般性的问题：当我完成向量后，我真的必须遍历它并在每个指针上调用delete吗？为什么我不必在没有新语句的情况下对向量或我声明的任何其他变量调用delete，而必须在指针上调用delete ?如果向量是在返回(导致向量超出范围)的函数中声明的，...

问在删除指向动态分配对象的指针矢量中的元素之前，我需要做什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在删除指向动态分配对象的指针矢量中的元素之前，我需要做什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在删除指向动态分配对象的指针矢量中的元素之前，我需要做什么？
EN