C++分析研究  
C++
日历
<2014年11月>
2627282930311
2345678
9101112131415
16171819202122
23242526272829
30123456
统计
  • 随笔 - 92
  • 文章 - 4
  • 评论 - 4
  • 引用 - 0

导航

常用链接

留言簿

随笔档案

文章档案

搜索

  •  

最新评论

阅读排行榜

评论排行榜

 

  常遇到的动态内存回收问题

  在C++的编程过程中,我们经常需要申请一块动态内存,然后当用完以后将其释放。通常而言,我们的代码是这样的:

  1: void func()

  2: {

  3: //allocate a dynamic memory

  4: int *ptr = new int;

  5:

  6: //use ptr

  7:

  8: //release allocated memory

  9: delete ptr;

  10: ptr = NULL;

  11: }

  如果这个函数func()逻辑比较简单,问题不大,但是当中间的代码有可能抛出异常时,上面的代码就会产生内存泄露(memory leak),如下面代码中第11行和12行将不会被执行。当然有码友会说用try-catch包起来就可以了,对,没错,但是代码中到处的try-catch也挺被人诟病的SAT答案 www.sats686.com

  1: void func()

  2: {

  3: //allocate a dynamic memory

  4: int *ptr = new int;

  5:

  6: throw “error”; //just an example

  7:

  8: //use ptr

  9:

  10: //release allocated memory

  11: delete ptr;

  12: ptr = NULL;

  13: }

  而且当函数有多个返回路径时,需要在每个return前都要调用delete去释放资源,代码也会变的不优雅了。

  1: void func()

  2: {

  3: //allocate a dynamic memory

  4: int *ptr = new int;

  5:

  6: if (...)

  7: {

  8: //...a

  9:

  10: //release allocated memory

  11: delete ptr;

  12: ptr = NULL;

  13: return;

  14: } else if (....)

  15: {

  16: //...b

  17:

  18: //release allocated memory

  19: delete ptr;

  20: ptr = NULL;

  21: return;

  22: }

  23:

  24: //use ptr

  25:

  26: //release allocated memory

  27: delete ptr;

  28: ptr = NULL;

  29: }

  鉴于此,我们就要想办法利用C++的一些语言特性,在函数退栈时能够将局部申请的动态内存自动释放掉。熟悉C++的码友们都知道,当一个对象退出其定义的作用域时,会自动调用它的析构函数。也就是说如果我们在函数内定义一个局部对象,在函数返回前,甚至有异常产生时,这个局部对象的析构函数都会自动调用。如果我们能够将释放资源的代码交付给这个对象的析构函数,我们就可以实现资源的自动回收。这类技术,通常被称为RAII (初始化中获取资源)托福答案


  什么是RAII以及几个例子

  在C++等面向对象语言中,为了管理局部资源的分配以及释放(resource allocation and deallocation),实现异常安全(exception-safe)、避免内存泄露等问题,C++之父Bjarne Stroustrup发明了一种叫做”初始化中获取资源“ (RAII, Resource Acquisition Is Initialization,也可以叫做Scope-Bound Resource Management)的技术。简单来说,它的目的就是利用一个局部对象,在这个对象的构造函数内分配资源,然后在其析构函数内释放资源。这样,当这个局部对象退出作用域时,它所对应的的资源即可自动释放。在实现上,它通常有三个特点:

  创建一个特殊类,在其构造函数初申请资源;

  封装目标对象,将申请资源的目标对象作为这个特殊类的成员变量;

  在这个类的析构函数内,释放资源。

  一个典型的例子就是标准库中提供的模板类std::auto_ptr。如在《C++程序设计语言》(《The C++ Programming Language, Special Edition》, Bjarne Stroustrup著,裘宗燕译)中第327页所描述的SAT答案

  1: template

  2: class std::auto_ptr {

  3:

  4: public:

  5: //在构造函数中,获得目标指针的管理权

  6: explicit auto_ptr(X *p = 0) throw() { ptr = p; }

  7: //在析构函数中,释放目标指针

  8: ~auto_ptr() throw() { delete ptr; }

  9:

  10: //...

  11:

  12: //重装*和->运算符,使auto_ptr对象像目标指针ptr一样使用

  13: X& operator*() const throw() { return *ptr; }

  14: X* operator->() const throw() { return ptr; }

  15:

  16: //放弃对目标指针的管理权

  17: X* release() throw() { X* t = ptr; ptr = 0; return t; }

  18:

  19: private:

  20: X *ptr;

  21: };

  想要使用它,非常简单,例如

  1: #include

  2:

  3: void func()

  4: {

  5: std::auto_ptr p(new int);

  6:

  7: //use p just like ptr

  8:

  9: return;

  10: }

  另一个例子,是利用GCC中的cleanup attribute。它可以指定一个函数,在该变量退出作用域时可以执行。例如Wikipedia上提到的宏

  1: #define RAII_VARIABLE(vartype,varname,initval,dtor) \

  2: void _dtor_ ## varname (vartype * v) { dtor(*v); } \

  3: vartype varname __attribute__((cleanup(_dtor_ ## varname))) = (initval)

  我们可以这样使用,例如

  1: void example_usage() {

  2: RAII_VARIABLE(FILE*, logfile, fopen("logfile.txt", "w+"), fclose);

  3: fputs("hello logfile!", logfile);

  4: }

  还有一个例子,是在刘未鹏的博客文章”C++11 (及现代C++风格)和快速迭代式开发“中的”资源管理“一节中看到的,他借助C++11的std::function实现了这一特性。感兴趣的码友可以到他博客内阅读。

  笔者采用的方法

  对于new/delete,使用上面提到的std::auto_ptr就可以了,但是对于new/delete[]一个动态的一维数组,甚至二维数组,auto_ptr就无能为力了。而且在一些项目中,特别是一些有着悠久历史的代码中,还存在着使用malloc, new混用的现象。所以笔者设计了一个auto_free_ptr类,实现目标资源的自动回收。它的实现比较简单,只利用了RAII的第三个特点——”在类的析构函数内释放资源”,但有一个优点是可以在申请堆内存代码前使用托福答案

  代码如下,

  1: //auto_free_ptr is only used for automation free memory

  2: template

  3: class auto_free_ptr

  4: {

  5: public:

  6: typedef enum {invalid, new_one, new_array, alloc_mem} EFLAG;

  7: auto_free_ptr() { initialize(); }

  8: ~auto_free_ptr(){ free_ptr(); }

  9:

  10: ///set the pointer needed to automatically free

  11: inline void set_ptr(T** new_ptr_address, EFLAG new_eflag)

  12: { free_ptr(); p_ptr = new_ptr_address; eflag = new_eflag; }

  13:

  14: ///give up auto free memory

  15: inline void give_up() { initialize(); }

  16:

  17: protected:

  18: inline void initialize() { p_ptr = NULL; eflag = invalid; }

  19: inline void free_ptr() throw()

  20: {

  21: if(!p_ptr || !(*p_ptr)) return;

  22:

  23: switch(eflag)

  24: {

  25: case alloc_mem: { free(*p_ptr), (*p_ptr) = NULL, p_ptr = NULL; break; }

  26: case new_one: { delete (*p_ptr), (*p_ptr) = NULL, p_ptr = NULL; break; }

  27: case new_array: { delete[] (*p_ptr),(*p_ptr) = NULL, p_ptr = NULL; break; }

  28: }

  29: }

  30:

  31: protected:

  32: T** p_ptr; //!< pointer to the address of the set pointer needed to automatically free

  33: EFLAG eflag; //!< the type of allocation

  34:

  35: private:

  36: DISABLE_COPY_AND_ASSIGN(auto_free_ptr);

  37: };
  为了使用方便,封装两个宏:

  1: // auto-free macros are mainly used to free the allocated memory by some local variables in the internal of function-body

  2: #define AUTO_FREE_ENABLE( class, ptrName, ptrType ) \

  3: auto_free_ptr auto_free_##ptrName; \

  4: auto_free_##ptrName.set_ptr(&ptrName,auto_free_ptr::ptrType)

  5:

  6: #define AUTO_FREE_DISABLE( ptrName ) auto_free_##ptrName.give_up()

  使用起来很简单,例如

  1: void func(int nLftCnt, int nRhtCnt)

  2: {

  3: if (!nLftCnt && !nRhtCnt)

  4: return;

  5:

  6: unsigned *pLftHashs = NULL;

  7: unsigned *pRhtHashs = NULL;

  8:

  9: //在申请堆内存之前,使用auto_free_ptr

  10: AUTO_FREE_ENABLE(unsigned, pLftHashs, new_array);

  11: AUTO_FREE_ENABLE(unsigned, pRhtHashs, new_array);

  12:

  13: //....

  14:

  15: if (nLftCnt)

  16: {

  17: pLftHashs = new unsigned[nLftCnt];

  18: //...a

  19: }

  20:

  21: if (nRhtCnt)

  22: {

  23: pRhtHashs = new unsigned[nRhtCnt];

  24: //...b

  25: }

  26:

  27: //....

  28:

  29: if (...)

  30: {

  31: //因为下面这个函数可以释放资源,所以在它前面放弃对目标指针的管理权

  32: AUTO_FREE_DISABLE(pLftHashs);

  33: AUTO_FREE_DISABLE(pRhtHashs);

  34:

  35: //这个函数可以释放资源

  36: free_hash_arrays(pLftHashs, pRhtHashs);

  37: }

  38: }

  同样的,有时我们需要申请一个动态二维数组,所以也实现一个对应的auto_free_2D_ptr

  1: //auto_free_2D_ptr is only used for automation free memory of 2D array

  2: template

  3: class auto_free_2D_ptr

  4: {

  5: public:

  6: typedef enum {invalid, new_one, new_array, alloc_mem} EFLAG;

  7: auto_free_2D_ptr() { initialize(); }

  8: ~auto_free_2D_ptr() { free_ptr(); }

  9:

  10: ///set the pointer needed to automatically free

  11: inline void set_ptr( T** new_ptr_address,EFLAG new_eflag, int new_length_row )

  12: { free_ptr(); p_ptr = new_ptr_address; eflag = new_eflag; length_row = new_length_row; }

  13:

  14: //give up auto free memory

  15: inline void give_up() { initialize(); }

  16:

  17: protected:

  18: inline void initialize() { p_ptr = NULL; eflag = invalid; length_row = 0;}

  19: inline void free_ptr() throw()

  20: {

  21: if(!p_ptr || !(*p_ptr)) return;

  22:

  23: for(int i = 0; i < length_row; i++)

  24: {

  25: if(!(*p_ptr)[i]) continue;

  26: switch(eflag)

  27: {

  28: case alloc_mem: { free((*p_ptr)[i]); break; }

  29: case new_one: { delete (*p_ptr)[i]; break; }

  30: case new_array: { delete[] (*p_ptr)[i]; break; }

  31: }

  32: (*p_ptr)[i] = NULL;

  33: }

  34: switch(eflag)

  35: {

  36: case alloc_mem: { free((*p_ptr)); break; }

  37: default: { delete[] (*p_ptr); break; }

  38: }

  39: (*p_ptr) = NULL, p_ptr = NULL;

  40: }

  41:

  42: protected:

  43: T** p_ptr; //!< pointer to the address of the set pointer needed to automatically free

  44: EFLAG eflag; //!< the type of allocation

  45: int length_row; //!< the row length such as ptr[length_row][length_col]

  46:

  47: private:

  48: DISABLE_COPY_AND_ASSIGN(auto_free_2D_ptr);

  49: };

  50:

  51: #define AUTO_FREE_2D_ENABLE( class, ptrName, ptrType, rowNum ) \

  52: auto_free_2D_ptr auto_free_##ptrName; \

  53: auto_free_##ptrName.set_ptr(&ptrName,auto_free_2D_ptr::ptrType, rowNum)

  54:

  55: #define AUTO_FREE_2D_DISABLE( ptrName ) AUTO_FREE_DISABLE( ptrName )

  下面是个例子

  1: void func(int row, int col)

  2: {

  3: if (!row && !col)

  4: return;

  5:

  6: int **ptr = new int*[ row ];

  7: for( int r = 0; r < row; ++r ) { ptr[r] = new int[ col ];}

  8:

  9: AUTO_FREE_2D_ENABLE( int, ptr, new_array, row );

  10:

  11: //....

  12: }

  到这里就结束了,有些码友可能会说,何必这么麻烦,boost内有很多智能指针供选择,用share_ptr, scoped_ptr, scoped_array,unique_ptr, auto_ptr 中的一个不就行了吗? 没错!如果你正在开发的代码中,允许用boost,并且在相关程序接口统一都用智能指针来管理、不会用到源对象指针的话,当然优先选boost,但是当你的代码中由于历史原因,有些接口不可变更,且new/delete, malloc/free都存在,而且依然需要使用源对象指针来完成大部分工作时,不妨试试我设计的这个阉割版的scoped_ptr/scoped_array。总之,根据自己的实际情况来选择合适的方案,如果标准方案不适用,就自己写一个托福答案

posted on 2014-11-16 09:05 HAOSOLA 阅读(637) 评论(0)  编辑 收藏 引用

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理


 
Copyright © HAOSOLA Powered by: 博客园 模板提供:沪江博客
PK10开奖 PK10开奖