释放vector内存的两种方法

[yshuise]

经常听见有人说vector内存是不可以释放的。实际上这是一种误解，
下面提供两种方法，各有千秋：

int a[10] = {12,3,45,6,7,2,45,5,2,10};
vector<int> S(a,a+10);
S.swap(vector<int>());

这是利用swap函数，和临时对象交换，使S对象的内存为临时对象的内存一样，而临时
对象的内存为S对象的内存。交换以后，临时对象消失，释放内存。不是传统所说的，程序退出才释放内存。
这可以调试跟踪一下。而且我们为了调整S的容纳3个元素，可以这样写：

S.swap(vector<int>(3));

我还记得这个论坛上有人问为什么要把swap写成成员函数，而不直接调用std::swap,其原因在于封装。
也就是假如需要交换的变量是有3个，那么std::swap要写成3次：
如：

void swap(vector<_Tp, _Alloc>& __x) {
    __STD::swap(_M_start, __x._M_start);//一次
    __STD::swap(_M_finish, __x._M_finish);//二次
    __STD::swap(_M_end_of_storage, __x._M_end_of_storage);//三次
  }

而且，在类外面的swap是无法调用类的私有成员的。swap还具有一个非常重要的优点——不抛出异常。



另外一种释放的方法，就很少人用了：

vector<int> S;
int* p = S.get_allocator().allocate(10);
S.get_allocator().deallocate(p,10);

[healer_kx]

前一阵子还有人发帖说alloc设计的不好呢，就是那个《代码大全》倒数的译者。
我感觉，凑合用吧，好处是可以定制，比如可以把gc融合进去。

但是lz本身的问题，为什么要显式释放呢？这两种我都不会用，只是很清楚alloc都干了什么，和vector关系。
我觉得不需要自己释放。难道很着急用内存？

[yshuise]

[Quote=引用 16 楼 loaden 的回复:]
引用 15 楼 yshuise 的回复:
dd

总算有人顶了。
我想跟帖，咋这么费劲啊。

我发现：这个allocator很不好用嘀。。。
这里有个文章，楼主可有兴趣看看？
http://oss.org.cn/?action-viewnews-itemid-3744
[/Quote]
文章太长了。以后再看。

[yshuise]

[Quote=引用 17 楼 healer_kx 的回复:]
前一阵子还有人发帖说alloc设计的不好呢，就是那个《代码大全》倒数的译者。
我感觉，凑合用吧，好处是可以定制，比如可以把gc融合进去。

但是lz本身的问题，为什么要显式释放呢？这两种我都不会用，只是很清楚alloc都干了什么，和vector关系。
我觉得不需要自己释放。难道很着急用内存？

[/Quote]
我在VC2008下初略测试了下，release下表现还不错。比单独用malloc好，也比boost::pool好（估计优化的问题）。

[healer_kx]

[Quote=引用 19 楼 yshuise 的回复:]
引用 17 楼 healer_kx 的回复:
前一阵子还有人发帖说alloc设计的不好呢，就是那个《代码大全》倒数的译者。
我感觉，凑合用吧，好处是可以定制，比如可以把gc融合进去。

但是lz本身的问题，为什么要显式释放呢？这两种我都不会用，只是很清楚alloc都干了什么，和vector关系。
我觉得不需要自己释放。难道很着急用内存？


我在VC2008下初略测试了下，release下表现还不错。比单独用malloc好，也比boost::pool好（估计优化的问题）。

[/Quote]
? 啥意思，没懂你说的，和我说的什么关系啊。。。

[yshuise]

#include "stdafx.h"  
#include <iostream>   
#include <vector>  
#include <time.h>   
#include <boost/pool/pool_alloc.hpp>   
template<typename T>   
class alloc    
{   
public:   
    typedef std::size_t     size_type;   
    typedef std::ptrdiff_t  difference_type;   
    typedef T*    pointer;   
    typedef const T* const_pointer;   
    typedef T&    reference;   
    typedef const T& const_reference;   
    typedef T     value_type;   
public:   
         alloc(){}   
     template<typename T>   
     alloc(const alloc<T>& ){   
     }   
     alloc& operator=(const alloc& rhs){   
         return *this;   
     }   
     static pointer allocate(size_type n)   
     {   
         return (pointer)malloc(n*sizeof(T));   
     }   
    static void deallocate(pointer ptr, size_type n)   
    {   
        free((pointer)ptr);   
    }   
    size_type max_size() const throw()    
    {    
        return size_t(-1) / sizeof(T);   
    }   
    template <typename U>   
    struct rebind   
    {    
        typedef alloc<U> other;   
    };   
       
};   
int _tmain(int argc, _TCHAR* argv[])   
{         
       
    int start4 = GetTickCount();   
    std::vector<int, alloc<int>> RR4;   
    for (int i = 0; i < 10000000; i++)   
    {   
        RR4.push_back(i);   
           
    }   
    int time4 = GetTickCount()- start4;   
    std::cout<<"alloc: "<<time4<<std::endl;   
    int start3 = GetTickCount();   
    std::vector<int, boost::fast_pool_allocator<int>> RR3;   
    for (int i = 0; i < 10000000; i++)   
    {   
        RR3.push_back(i);   
    }   
    int time3 = GetTickCount()- start3;   
    std::cout<<"boost::fast_pool_allocator: "<<time3<<std::endl;   
    int start1 = GetTickCount();   
    std::vector<int,std::allocator<int>> RR1;   
    for (int i = 0; i < 10000000; i++)   
    {   
        RR1.push_back(i);   
    }   
    int time1 = GetTickCount()- start1;   
    std::cout<<"std::allocator: "<<time1<<std::endl;   
  
    int start2 = GetTickCount();   
    std::vector<int, boost::pool_allocator<int>> RR2;   
    for (int i = 0; i < 10000000; i++)   
    {   
        RR2.push_back(i);   
    }   
    int time2 = GetTickCount()- start2;   
    std::cout<<"boost::pool_allocator: "<<time2<<std::endl;   
    return 0;   
}  

debug (VC2008):

alloc: 11438   
boost::fast_pool_allocator: 19437   
std::allocator: 11562   
boost::pool_allocator: 27703   
请按任意键继续. . .  

Release(VC2008):

alloc: 375   
boost::fast_pool_allocator: 1032   
std::allocator: 343   
boost::pool_allocator: 1266   
请按任意键继续. . .  

[yshuise]

? 啥意思，没懂你说的，和我说的什么关系啊。。。
==============
标准那个还不错的意思。见21楼。

[taodm]

呃，stl，2级内存管理，swap技巧真能起作用？
还好看过stl源码剖析

[healer_kx]

啊，效率不错啊，因为STL源码剖析里面讲std::alloctor使用了小对象内存池。
我自己也模拟写了一个。

[yshuise]

[Quote=引用 23 楼 taodm 的回复:]
呃，stl，2级内存管理，swap技巧真能起作用？
还好看过stl源码剖析
[/Quote]
当然能。《more exceptional c++》的前面（具体是多少记不得了）
《effictive STL》也讲了这个技巧。

[ZXW0521]

进来学习的，
刚开始看stl源码解析，

[yshuise]

[Quote=引用 26 楼 zxw0521 的回复:]
进来学习的，
刚开始看stl源码解析，
[/Quote]
这是本非常优秀的书籍。

[pengzhixi]

内存适配器，现在都不怎么直接用了吧

[jiqing_gao]

好啊

[macrojj]

我想知道什么时候 需要自己去释放。

[cattycat]

这个释放需要自己显示调用dealocator才能释放。

[fallening]

vector<double> x;
//x......
vector<double>(x).swap(x);

这种么？

[lovecl85]

不错，顶啦，学习

[moving218]

顶 这个太强了

[ylywxhn]

深奥~~

[xiaolomg]

的确比较深奥