最近在论坛看到一个提问帖子，问题是vector中存储了对象的指针，调用clear后这些指针如何删除？
- class Test
- {
- public:
- Test() {}
- ~Test() { cout << "Test des" << endl; }
- };
- int main()
- {
- vector<Test*> vec;
- vec.push_back(new Test());
- vec.push_back(new Test());
- vec.push_back(new Test());
- //对象如何进行释放，要调用已定义析构函数
- vec.clear();
- return 0;
- }
同时最近又看到一道面试题:对于STL中的vector调用clear时，内部是如何操作的？若想将其内存释放，该如何操作？
针对以上两个问题，我们追踪一下STL源码。
- // 清除全部元素。注意并未释放空间，以备可能未来还会新加入元素。
- void clear() { erase(begin(), end()); }
- //调用vector::erase的两迭代器范围版本
- iterator erase(iterator first, iterator last) {
- iterator i = copy(last, finish, first);
- //finish在vector中定义表示目前使用空间的尾，相当于end（），clear调用时last=finish
- destroy(i, finish); //全局函数，结构的基本函数
- finish = finish - (last - first);
- return first;
- }
以上关键就是调用了destroy函数。destory函数在 <stl_construct.h>中定义，为了便于分析整个的构造与释放，将construct函数的内容也进行了摘录。这其中要注意的是traits技术。
// destroy()单指针版本 template <class T> inline void destroy(T* pointer) { pointer->~T(); // 唤起 dtor ~T() } // destroy()两迭代器版本 //利用 __type_traits<> 求取最适当措施。 template <class ForwardIterator> inline void destroy(ForwardIterator first, ForwardIterator last) { __destroy(first, last, value_type(first)); } //判断元素的数值型别（value type）有 non-trivial destructor(自定义析构函数) template <class ForwardIterator, class T> inline void __destroy(ForwardIterator first, ForwardIterator last, T*) { typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor; __destroy_aux(first, last, trivial_destructor()); } // 如果元素的数值型别（value type）有 non-trivial destructor(自定义析构函数) template <class ForwardIterator> inline void __destroy_aux(ForwardIterator first, ForwardIterator last, __false_type) { for ( ; first < last; ++first) //遍历元素进行析构 destroy(&*first); //!!!!!关键句!!!!!!!!! } //如果元素的数值型别（value type）有trivial destructor template <class ForwardIterator> inline void __destroy_aux(ForwardIterator, ForwardIterator, __true_type) {} //什么都不做，STL是用了一种保守的方式，只有内建的元素类型（int，float等）进行判定trivial destructor的时候才是__true_type其他一切用户自定义类型都是__false_type // destroy()两迭代器版本，针对char*与wchar_t*的特化版本 inline void destroy(char*, char*) {} inline void destroy(wchar_t*, wchar_t*) {} //仅仅是对placement new 的一层封装 template <class T1, class T2> inline void construct(T1* p, const T2& value) { new (p) T1(value); // placement new; 唤起 ctor T1(value); }
看到这里基本对上述的问题已经有答案了。
由于对象的指针不是内建对象，所以进行遍历析构。
for ( ; first <last; ++first) //遍历元素进行析构
destroy(&*first); //!!!!!关键句!!!!!!!!!
*iterator是元素类型，&*iterator是元素地址，也就是一个指针。之后调用&*iterator->~T();所以可知当vector中所存储的元素为对象的时候，调用clear（）操作的时候系统会自动调用析构函数。但是当存储元素是指针的时候，指针指向的对象就没法析构了。因此需要释放指针所指对象的话，需要在clear操作之前调用delete。
for(i= 0; i < vItem.size();i++)
delete vItem[i];
测试：
#include<iostream> #include<vector> using namespace std; class A{ private: int a_; public: A(int a) :a_(a){} ~A() { cout << "A destrout" << endl; } }; int main() { vector<A> vec; A *p1 = new A(1); A *p2 = new A(2); A *p3 = new A(3); vec.push_back(*p1); vec.push_back(*p2); vec.push_back(*p3); vec.clear(); }
为什么调用了6次析构函数？（提示，vector的动态增长。）
vector的clear成员函数可以清除vector中的元素，使其大小减至0。但它却不能减小vector占用的内存。
STLvector内存释放：
vector的clear成员函数可以清除vector中的元素，使其大小减至0。但它却不能减小vector占用的内存。
- int main()
- {
- vector<int> v(1U<<29);
- cout<<"step into stage one..."<<endl;
- sleep(30);
- v.clear();
- cout<<"step into stage two..."<<endl;
- sleep(30);
- return 0;
- }
stage one定义了vector对象，含有2^29个int元素，占用2G内存。stage two调用vector对象的clear成员函数，清除其中所有对象。程序运行过程中，使用ps或者top或者其他工具查看内存占用，会发现，程序在stage one确实占用了大约2GB的内存，但在stage two，程序仍然占用着2G内存。事实上，vector的clear成员只负责对其中每一个元素调用其析构函数，将vector的size置零，并不负责释放vector本身占用的内存空间。
若想释放vector占用的空间，可以使用swap技巧，
- int
- main()
- {
- vector<int> v(1U<<29);
- cout<<"step into stage one..."<<endl;
- sleep(30);
- vector<int>().swap(v);
- cout<<"step into stage two..."<<endl;
- sleep(30);
- return 0;
- }
vector()使用vector的默认构造函数建立临时vector对象，再在该临时对象上调用swap成员，swap调用之后对象v占用的空间就等于一个默认构造的对象的大小（寥寥），临时对象就具有原来对象v的大小，而该临时对象随即就会被析构，从而其占用的空间也被释放。
并不是所有的STL容器的clear成员的行为都和vector一样。事实上，其他容器的clear成员都会释放其内存。比如另一个和vector类似的顺序容器deque，
观察上面程序的行为，会发现程序在stage two的内存占用也是寥寥的了。
另外，值得一提的是vector具有reserve成员，会提前为容器预留一定的空间，以防止后的push_back操作导致频繁地重新分配内存和移动元素。然而，据我观察，reserve并没有向系统申请内存。
关于C++ STL容器的默认内存管理，需参考allocator。
关于deque的内存模型及其clear操作，我不甚了了，请参考您使用的标准库的代码。
若想深入了解STL的实现，侯捷大叔的《STL源码剖析》是不错的入门资料，希望能够拜读。
C++标准中并未对STL的实现细节做过多规定，因此不同实现的细节和表现可能不同。
C++很复杂，但也并非无底黑洞。学好C++很难，但这种学习过程也会使你收获颇丰。
学习任何一种技术，都需要热情、激情和足够的耐心。
做好一件事，需要激情，同时激情常常来源于做好一件事情的满足感。
满足感会增强人分享的欲望，分享的欲望也常常会使人具有亲和力和感染力，使人觉得你有激情，反过来更有利于人做好一件事。
blabla, over~
转自 http://www.dutor.net/index.php/2011/04/vector-deque-clear-reserve/
问题：stl中的vector容器常常造成删除假象，这对于c++程序员来说是极其讨厌的，《effective stl》大师已经将之列为第17条，使用交换技巧来修整过剩容量。
内存空洞这个名词是网上的学者给出的，我觉得用来描述这个基本现象特别容易提醒自己vector删除的这个陷阱。
首先给出一段代码：
35 void testvector()
36 {
38 vector v;
39 v.push_back(1);
40 v.push_back(2);
41 cout << "v size = " << v.size() << " v capacity = " << v.capacity() << endl;
42 v.erase(v.begin());
43 cout << "v size = " << v.size() << " v capacity = " << v.capacity() << endl;
44 vector<int>(v).swap(v); // 清除v而且最小化它的容量
45 cout << "v size = " << v.size() << " v capacity = " << v.capacity() << endl;
47 }
结果如下：
[hfx@didkey1 bin]$ ./test
v size = 2 v capacity = 2
v size = 1 v capacity = 2
v size = 1 v capacity = 1
分析：
可以清楚地看到这个问题，在第一次 v.erase(v.begin());的时候，并没有真正释放删除元素的内存，它的容量还是存着。我也简单描画下这个生活中的问题——
你拿这一个1000升的水去沙漠上旅行，开始是满的，但是，你的旅途让你的水变成了1升，而且路途中，你没有水资源让你再次灌满，那么，你一直将拖着一个1000升
容量的大水箱，载着1升水在旅行，你是不允许自己这样做的。你只有把这个水箱切了，切成10升或者1升，小点……
vector也一样，你把水喝了，并不能把水箱也缩小，要把水箱缩小的做法——
——swap()交换函数完美释放内存。
vector(v).swap(v); // 清除v而且最小化它的容量
注意：
a. erase()函数，只能删除内容，不能改变容量大小；
erase成员函数，它删除了itVect迭代器指向的元素，并且返回要被删除的itVect之后的迭代器，迭代器相当于一个智能指针。
b. clear()函数，只能清空内容，不能改变容量大小
c. vector容器删除不自动释放内存，那么它存在内存泄露？？？不是的，vector在析构函数的时候，对内存进行了释放。
d. 如果要想在删除内容的同时释放内存，那么你可以选择deque容器。
e. 关于vector：
vector相当于c++中的数组，数组在初始化的时候也需要给它一个数组空间大小，vector申请的时候将预留一个空间，比如10，在元素超过10的时候，vector自动将大小
扩大到两倍，并且将元素拷贝过去。
用法举例：
vector(v).swap(v);将v的内存空洞清除
vector().swap(v);清空vec
参考：http://blog.csdn.net/sicofield/article/details/8769612
第一种办法使用 clear ，清空元素，但不回收空间
- vecInt.clear();
- j= vecInt.capacity(); //j=512
- i = vecInt.size(); //i=0
第二种办法使用 erase循环删除，结果同上
- vector <int>::iterator iter=vecInt.begin();
- for ( ;iter!=vecInt.end();)
- {
- iter=vecInt.erase(iter);
- }
- j= vecInt.capacity(); //j=512
- i = vecInt.size(); //i=0
erase在每次操作时，迭代器指针会整体前移1，就是每次都会“搬”全部数据，所以vector不适合做频繁删除的容器
第三种办法 最简单的使用swap,清除元素并回收内存
- vector <int>().swap(vecInt); //清除容器并最小化它的容量，
- // vecInt.swap(vector<int>()) ; 另一种写法
- j= vecInt.capacity(); //j=0
- i = vecInt.size(); //i=0
该语句是由vector <int>(vecInt).swap(vecInt)的变体而来，一下解释引自csdn：
std::vector<T>(v).swap(v);的作用相当于：
{
std::vector<T> temp(v);//1
temp.swap(v);//2
}
第一句产生一个和v内容一模一样的vector，只不过temp的容量是恰好满足其大小的
第二句把v和temp交换
然后temp就自动解析掉了
这样写的作用是：把v的容量缩小到最佳值
vector<int> v; v.push_back(1); v.push_back(2); v.push_back(3); cout << v.capacity() << endl; v.erase(v.begin()); cout << "v.size()=" << v.size() << " v.capicyt" << v.capacity() << endl; vector<int>(v).swap(v); cout << "v.size()=" << v.size() << " v.capicyt" << v.capacity() << endl; vector<int>().swap(v); cout << "v.size()=" << v.size() << " v.capicyt" << v.capacity() << endl;
3
v.size()=2 v.capicyt3
v.size()=2 v.capicyt2
v.size()=0 v.capicyt0
请按任意键继续. . .
在《effective STL》和其实很多C++文章中都有指明，用clear()无法保证内存回收。但是swap技法可以。具体方法如下所示：
vector<int> nums;
nums.push_back(1);nums.push_back(1);nums.push_back(2);nums.push_back(2);
vector<int>().swap(nums); //或者nums.swap(vector<int>())；
vector<int>().swap(nums); 或者如下所示 加一对大括号都可以，意思一样的：
{
std::vector<int> tmp = nums;
nums.swap(tmp);
}
加一对大括号是可以让tmp退出{}的时候自动析构
swap技法就是通过交换函数swap（），使得vector离开其自身的作用域，从而强制释放vector所占的内存空间。
该例中执行这句时，capacity收缩到500
××××××××××××××××××××××
不过以上还是调用stl的函数看到的，不知其内部是如何做的。在网上看到其他人的讨论有这样：
@@而Cygwin中的GCC用的应该是HP STL或从它继承来的SGI STL，对于小内存有一种缓冲池机制，一旦进池的内存就再也不会交还给系统了
@@swap 不起作用, 因为原因是 allocator.
更多：http://blog.csdn.net/sicofield/article/details/8769624