Chinaunix首页 | 论坛 | 博客
  • 博客访问: 541086
  • 博文数量: 129
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 1888
  • 用 户 组: 普通用户
  • 注册时间: 2013-06-20 11:09
文章分类

全部博文(129)

文章存档

2016年(1)

2015年(5)

2014年(64)

2013年(59)

我的朋友

分类: C/C++

2013-11-06 09:58:18

一、智能指针
     由于 C++ 语言没有自动内存回收机制,程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete,流程太复杂,最终导致没有 delete,异常导致程序过早退出,没有执行 delete 的情况并不罕见。然而标准C++中还有一个强大的模版类就是auto_ptr,它可以在你不用的时候自动帮你释放内存。

对于编译器来说,智能指针实际上是一个栈对象,并非指针类型,在栈对象生命期即将结束时,智能指针通过析构函数释放有它管理的堆内存。所有智能指针都重载了“operator->”操作符,直接返回对象的引用,用以操作对象。访问智能指针原来的方法则使用“.”操作符。

访问智能指针包含的裸指针则可以用 get() 函数。由于智能指针是一个对象,所以if (my_smart_object)永远为真,要判断智能指针的裸指针是否为空,需要这样判断:if (my_smart_object.get())

智能指针包含了 reset() 方法,如果不传递参数(或者传递 NULL),则智能指针会释放当前管理的内存。如果传递一个对象,则智能指针会释放当前对象,来管理新传入的对象。


二、auto_ptr模板类源代码

      auto_ptr模板类的源代码如下:
   
  1. template <class T>
  2. class auto_ptr {
  3. private:
  4.     T* ap;
  5. public:
  6.     // constructor & destructor ----------------------------------- (1)
  7.     explicit auto_ptr (T* ptr = 0) throw() : ap(ptr) { }
  8.     ~auto_ptr() throw() {
  9.         delete ap;
  10.     }
  11.     // copy  & assignment --------------------------------------------(2)
  12.     auto_ptr (auto_ptr& rhs) throw() : ap(rhs.release()) { }
  13.     template <class Y>
  14.     auto_ptr(auto_ptr<Y>& rhs) throw() : ap(rhs.release()) { }
  15.     
  16.     auto_ptr& operator= (auto_ptr& rhs) throw() {
  17.     reset(rhs.release());
  18.     return *this;
  19. }
  20. template <class Y>
  21. auto_ptr& operator= (auto_ptr<Y>& rhs) throw() {
  22.     reset(rhs.release());
  23.     return *this;
  24. }
  25. // Dereference----------------------------------------------------(3)
  26. T& operator*() const throw() {
  27.     return *ap;
  28. }
  29. T* operator->() const throw() {
  30.     return ap;
  31. }
  32. // Helper functions------------------------------------------------(4)
  33. // value access
  34. T* get() const throw () {
  35.     return ap;
  36. }
  37. // release ownership
  38. T* release() throw() {
  39.     T* tmp(ap);
  40.     ap = 0;
  41.     return tmp;
  42. }
  43. // reset value
  44. void reset (T* ptr=0) throw() {
  45.     if (ap != ptr){
  46.         delete ap;
  47.         ap = ptr;
  48.     }
  49. }
  50. // Special conversions-----------------------------------------------(5)
  51. template<class Y>
  52. struct auto_ptr_ref {
  53.     Y* yp;
  54.     auto_ptr_ref(Y* rhs) : yp(rhs) { }
  55. };
  56. auto_ptr(auto_ptr_ref<T> rhs) throw() : ap(rhs.yp) { }
  57. auto_ptr& operator= (auto_ptr_ref<T> rhs) throw() {
  58.     reset(rhs.yp);
  59.     return *this;
  60. }
  61. template <class Y>
  62. operator auto_ptr_ref<Y>() throw() {
  63.     return auto_ptr_ref<Y>(release());
  64. }
  65. template <class Y>
  66. operator auto_ptr<Y>() throw() {
  67.     return auto_ptr<Y>(release());
  68. }
  2.1 构造函数与析构函数
   
auto_ptr在构造时获取对某个对象的所有权(ownership),在析构时释放该对象。我们可以这样使用auto_ptr来提高代码安全性:
         
  1. int* p = new int(0);
  2. auto_ptr<int> ap(p);
从此我们不必关心应该何时释放p,也不用担心发生异常会有内存泄漏。
这里我们有几点要注意:
  1) 因为auto_ptr析构的时候肯定会删除他所拥有的那个对象,所有我们就要注意了,一个萝卜一个坑,两个auto_ptr不能同时拥有同一个对象。像这样:
  1. int* p = new int(0);
  2. auto_ptr<int> ap1(p);
  3. auto_ptr<int> ap2(p);
    因为ap1与ap2都认为指针p是归它管的,在析构时都试图删除p, 两次删除同一个对象的行为在C++标准中是未定义的。所以我们必须防止这样使用auto_ptr.

   2) 考虑下面这种用法:
 
  1. int* pa = new int[10];
  2. auto_ptr<int> ap(pa);
因为auto_ptr的析构函数中删除指针用的是delete,而不是delete [],所以我们不应该用auto_ptr来管理一个数组指针。
   
3) 构造函数的explicit关键词有效阻止从一个“裸”指针隐式转换成auto_ptr类型。
   
4) 因为C++保证删除一个空指针是安全的, 所以我们没有必要把析构函数写成:
  1. ~auto_ptr() throw()
  2. {
  3.     if(ap) delete ap;
  4. }


 2.2  拷贝构造函数与重载运算符=
      与引用计数型智能指针不同的,auto_ptr要求其对“裸”指针的完全占有性。也就是说一个”裸“不能同时被两个以上的auto_ptr所拥有。那么,在拷贝构造或赋值操作时,我们必须作特殊的处理来保证这个特性。auto_ptr的做法是“所有权转移”,即拷贝或赋值的源对象将失去对“裸”的所有权,所以,与一般,不同, auto_ptr的拷贝构造函数,的参数为引用而不是常引用(const reference).当然,一个auto_ptr也不能同时拥有两个以上的“裸”指针,所以,拷贝或赋值的目标对象将先释放其原来所拥有的对象。
这里的注意点是:
1) 因为一个auto_ptr被拷贝或被赋值后, 其已经失去对原对象的所有权,这个时候,对这个auto_ptr的提领(dereference)操作是不安全的。如下:
    
  1. int* p = new int(0);
  2. auto_ptr<int> ap1(p);
  3. auto_ptr<int> ap2 = ap1;       //调用拷贝构造函数,将ap1对p的使用权给ap2,ap1不再占用
  4. cout << *ap1;                  //错误,此时ap1只剩一个null指针在手了
这种情况较为隐蔽的情形出现在将auto_ptr作为函数参数按值传递,因为在过程中在函数的中会产生一个局部对象来接收传入的auto_ptr(拷贝构造),这样,传入的auto_ptr就失去了其对原对象的所有权,而该对象会在函数退出时被局部auto_ptr删除。如下:


  1. void f(auto_ptr<int> ap){cout<<*ap;}
  2. auto_ptr<int> ap1(new int(0));
  3. f(ap1);
  4. cout << *ap1; //错误,经过f(ap1)函数调用,ap1已经不再拥有任何对象了。
 
因为这种情况太隐蔽,太容易出错了, 所以auto_ptr作为函数参数按值传递是一定要避免的。或许大家会想到用auto_ptr的或引用作为函数参数或许可以,但是仔细想想,我们并不知道在函数中对传入的auto_ptr做了什么, 如果当中某些操作使其失去了对对象的所有权, 那么这还是可能会导致致命的执行期错误。 也许,用const reference的形式来传递auto_ptr会是一个不错的选择。
2)我们可以看到与赋值函数都提供了一个成员模板在不覆盖“正统”版本的情况下实现auto_ptr的隐式转换。如我们有以下两个类
     
  1. class base{};
  2. class derived: public base{};
 那么下列代码就可以通过,实现从auto_ptr到auto_ptr的隐式转换,因为derived*可以转换成base*类型
 
  1. auto_ptr<base> apbase = auto_ptr<derived>(new derived);
 
3) 因为auto_ptr不具有值语义(value semantic), 所以auto_ptr不能被用在stl标准容器中。
所谓值语义,是指符合以下条件的类型(假设有类A):
 
  1. A a1;
  2. A a2(a1);
  3. A a3;
  4. a3 = a1;
  5. // 那么
  6. a2 == a1, a3 == a1
很明显,auto_ptr不符合上述条件,而我们知道stl标准容器要用到大量的拷贝赋值操作,并且假设其操作的类型必须符合以上条件。
2.3  提领操作(dereference)
提领操作有两个操作, 一个是返回其所拥有的对象的引用, 另一个是则实现了通过auto_ptr调用其所拥有的对象的成员。如:
 
  1. struct A
  2. {
  3.     void f();
  4. }
  5. auto_ptr<A> apa(new A);
  6. (*apa).f();
  7. apa->f();
  
当然, 我们首先要确保这个确实拥有某个对象,否则,这个操作的行为即对空指针的提领是未定义的。
2.4  辅助函数
1) get用来显式的返回auto_ptr所拥有的。我们可以发现,标准库提供的auto_ptr既不提供从“裸”到auto_ptr的隐式转换(为explicit),也不提供从auto_ptr到“裸”指针的隐式转换,从使用上来讲可能不那么的灵活,考虑到其所带来的安全性还是值得的。
2) release,用来转移所有权
3) reset,用来接收所有权,如果接收所有权的auto_ptr如果已经拥有某对象,必须先释放该对象。
2.5  特殊转换
这里提供一个辅助类auto_ptr_ref来做特殊的转换,按照标准的解释, 这个类及下面4个函数的作用是:使我们得以拷贝和赋值non-const auto_ptrs, 却不能拷贝和赋值const auto_ptrs. 我无法非常准确的理解这两句话的意义,但根据我们观察与试验,应该可以这样去理解:没有这些代码,我们本来就可以拷贝和赋值non-const的auto_ptr和禁止拷贝和赋值const的auto_ptr的功能, 只是无法拷贝和赋值临时的auto_ptr(右值), 而这些辅助代码提供某些转换,使我们可以拷贝和赋值临时的auto_ptr,但并没有使const的auto_ptr也能被拷贝和赋值。如下:

  1. auto_ptr<int> ap1 = auto_ptr<int>(new int(0));
  2. 1
  3. auto_ptr<int>(new int(0))
是一个临时对象,一个右值,一般的当然能拷贝右值,因为其参数类别必须为一个const reference, 但是我们知道,auto_ptr的拷贝函数其参数类型为reference,所以,为了使这行代码能通过,我们引入auto_ptr_ref来实现从右值向的转换。其过程为:
1) ap1要通过拷贝 auto_ptr(new int(0))来构造自己
2) auto_ptr(new int(0))作为右值与现有的两个参数类型都无法匹配,也无法转换成该种参数类型
3) 发现辅助的auto_ptr(auto_ptr_ref rhs) throw()
4) 试图将auto_ptr(new int(0))转换成auto_ptr_ref
5) 发现operator auto_ptr_ref() throw(), 转换成功,从而拷贝成功。
从而通过一个间接类成功的实现了拷贝构造右值(临时对象)
同时,这个辅助方法不会使const auto_ptr被拷贝, 原因是在第5步, 此为non-const的,我们知道,const对象是无法调用non-const成员的, 所以转换失败。当然, 这里有一个问题要注意, 假设你把这些辅助转换的代码注释掉,该行代码还是可能成功编译,这是为什么呢?debug一下, 我们可以发现只调用了一次,而并没有被调用,原因在于掉了。这种类型优化叫做returned value optimization,它可以有效防止一些无意义的临时对象的构造。当然,前提是你的要支持returned value optimization。

三、auto_ptr实例
   3.1 对auto_ptr模板类的基本函数的使用:

  1. #include<iostream>
  2. #include<memory>
  3. using namespace std;

  4. class Simple
  5. {
  6. public:
  7.     Simple(int param)
  8.     {
  9.         number=param;
  10.         cout<<"Simple constructor:"<<number<<endl;
  11.     }
  12.     ~Simple()
  13.     {
  14.         cout<<"~Simple:"<<number<<endl;
  15.     }
  16.     void PrintSomething()
  17.     {
  18.         cout<<"PrintSomething:"<<endl;
  19.     }

  20.     int number;
  21. };

  22. void TestAutoPtr()
  23. {

  24.     auto_ptr<Simple> my_memory(new Simple(1));
  25.     if(my_memory.get())
  26.     {
  27.         my_memory->PrintSomething();                   //对重载操作符->的使用
  28.         my_memory.get()->PrintSomething();             //对函数get()及重载操作符->的使用
  29.         cout<<(*my_memory).number<<endl;               //对重载操作符*的使用
  30.     }
  31.     Simple *ss=    my_memory.release(); 
  32.     my_memory->PrintSomething();                      //在上句my_memory.release()让出了所有权,不太懂为什么这句话还是能正常执行????
  33.     delete ss;                                        //若未加此句,则不会调用析构函数
  34. }

  35. int main()
  36. {
  37.     TestAutoPtr();
  38.     return 0;
  39. }
 运行结果如下:
 


   

3.2  拷贝构造函数与重载运算符=的实例
    
  1. #include<iostream>
  2. #include<memory>
  3. using namespace std;

  4. class Simple
  5. {
  6. public:
  7.     Simple(int param)
  8.     {
  9.      number=param;
  10.         cout<<"Simple constructor:"<<number<<endl;
  11.     }
  12.     ~Simple()
  13.     {
  14.         cout<<"~Simple:"<<number<<endl;
  15.     }
  16.     void PrintSomething()
  17.     {
  18.         cout<<"PrintSomething:"<<endl;
  19.     }

  20.     int number;
  21. };

  22. void TestAutoPtr()
  23. {

  24.     auto_ptr<Simple> my_memory(new Simple(1));
  25.     auto_ptr<Simple> my_memory2=my_memory;     //调用拷贝构造函数
  26.     
  27.     cout<<(*my_memory2).number<<endl;
  28.     my_memory->PrintSomething();              //??不是应该崩溃的吗?但运行结果却没有,没有弄懂????

  29. }

  30. int main()
  31. {
  32.     TestAutoPtr();
  33.     return 0;
  34. }
    运行结果如下:
           

小结:通过上面两个例子,却发现实际运行结果和我通过auto_ptr的源码的理解,出现了不一样的结论。在此先留着,以后研究透了再来修正。
四、auto_ptr实现关键点:

1. 利用特点“栈上对象在离开作用范围时会自动析构”。

2. 对于动态分配的内存,其作用范围是程序员手动控制的,这给程序员带来了方便但也不可避免疏忽造成的内存泄漏,毕竟只有编译器是最可靠的。

3. auto_ptr通过在栈上构建一个对象a,对象awrap了动态分配内存的指针p,所有对指针p的操作都转为对对象a的操作。而在a的析构函数中会自动释放p的空间,而该析构函数是编译器自动调用的,无需程序员操心。


参考:
   http://blog.sina.com.cn/s/blog_7708265a01010lyv.html
  http://blog.csdn.net/monkey_d_meng/article/details/5901392


















阅读(1168) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~