STL vector 内存释放

最近在论坛看到一个提问帖子，问题是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();

    A *p2 = new A();

    A *p3 = new A();

    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/

完美删除vector的“内存空洞”

问题：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(); v.push_back(); v.push_back();

    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

秒客网

STL vector 内存释放

相关文章