c++（smart pointer）

（一）首先对智能指针有一些概念性的了解

**********本部分内容摘自开源中国社区http://my.oschina.net/u/158589/blog/28994********

1.什么是智能指针？

智能指针（Smart Pointer），简单来说，就是用起来像指针，但是很聪明，可以自己在适当的时候删除动态分配的对象的指针。

2.什么时候使用智能指针？

智能指针主要用于生存期控制和阶段控制。比如，在一个类中，如果有指针成员，那么，如果类写的不够小心，就很容易出异常。因为指针指向的动态内存，必须在拷贝构造或者赋值时，复制一份同样大小的内存。否则，容易引起内存泄漏或者对未定义的指针就行删除。

3.使用智能指针的优势是什么？

多个对象间可以共享一份动态内存，并且不需要费心在动态内存的申请和释放上。关于第一点，我觉得有点像Linux下的文件管理系统的机制。

4.智能指针如何实现？

智能指针的实现，关键技术在于“引用计数“。具体来说，通常有两种方式：第一，使用辅助类。第二，使用句柄类。我们通常采用句柄类的方式来实现，原因是这样作可以减少客户代码和类代码之间的耦合性。

5.如何使用智能指针？

STL库中的auto_ptr和Boost中的一些智能指针。

（二）对智能指针的进一步分析

**********本部分内容摘自开源中国社区http://my.oschina.net/linuxred/blog/23666********

内存泄露是C++程序员都头疼的大问题。C++缺乏像JAVA、C#一样，拥有GC这么一项有利的武器，它将内存管理的部分权限交给了程序员。虽然GC的存在节约了开发、排错的时间与成本，但是C++为了追求运行速度而20年来坚决不予补充进其标准。（题外话：C++通过加大开发难度去换取执行速度的做法，在现在看来不知是否能给与正面的评价，还是留给将来再说吧。）从此，在堆上申请了内存忘了释放、所造成的内存泄露的问题就一直困扰着C++程序员。也许为了稍许弥补没有垃圾回收器所造成的开发门槛高，各大厂商开发的C++库中都像COM学习引入智能指针试图解决部分目前存在的问题。
  智能指针是存储指向动态分配（堆）对象指针的类, 用于生存期控制, 能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。 
     说到智能指针，我们一定要看看标准C++库提供的“搞笑的”智能指针:auto_ptr。 
  标准库中提供了C++程序的基本设施。虽然C++标准库随着C++标准折腾了许多年，直到标准的出台才正式定型，网上评论C++标准库时都说：“在标准库的实现上却很令人欣慰得看到多种实现，并且已被实践证明为有工业级别强度的佳作。”但目前的标准C++中，只有一种独苗智能指针：std::auto_ptr。 
  auto_ptr指针是一个RAII对象,它初始化时获得资源,析构时自动释放资源(生命期结束).它的缺点数不胜数： 
1、auto_ptr要求一个对象只能有一个拥有者，严禁一物二主 
2、缺少对引用数和数组的支持。 
3、不可将auto_ptr对象作为STL容器的元素。C++标准明确禁止这样做，否则可能会碰到不可预见的结果。（这一条晕死一大片）。 
4、auto_ptr在被复制的时候会传输所有权 
反正由此可见：标准库的智能指针就是无甚大用。 
    在这样的情况下，C++标准委员会自然需要考虑引入新的智能指针。目前由C++标准委员会库工作组发起的Boost 组织开发了Boost系列智能指针。 
  在Boost中的智能指针有五种： scoped_ptr，scoped_array，shared_ptr，shared_array，weak_ptr. 
前4种完全是针对标准库中的auto_ptr提出解决方案，如：scope_ptr是针对“auto_ptr在被复制的时候会传输所有权”这一弱点提出的。最后一种没见过，看名字像是弱引用智能指针，我怀疑是不是类似于JAVA中弱引用一样,有待进一步学习。 
Smart Pointer是C++中的一个大题目，要说清楚他的所有好处很需要费点力气。我就一个功能一个功能的说。有我理解不透的地方希望大家指点。 
1.copy-to-write 
当生成一个C++ object的时候如果这个class很大，这个object会占用很多空间。那么每生成一个就占用一片空间，这样会占用很多系统资源。同时降低效率。一个解决方法就是对用拷贝构造函数生成的object，让他不存储数据，而只存储一个指向原来object数据的指针。 这样空间就节省了很多。但问题在于这样两个object完全联结在了一起。如果修改了其中一个，另一个也跟着变了。所以这种方法不可取。这里讲的 copy-to-write技术就是解决这类问题的方法。当通过引用一个已有object去拷贝构造新object时，新object只有一个指向已有object的指针。这两个object共享数据。直到其中一个需要修改数据的时候，再把这两块数据分离。这里举一个最简化的例子。假设一个class叫 CLargeObject，里面存有很多数据。我们用一个inner class来把所有数据放在一起，叫CData。CData里面存有大量数据，例如一个数据库。这里用最简单的模型来表示，假设只有一个整数int m_nVal; CData里面需要包含另一个变量。叫作索引数目(reference count)。它记录了指向这个CDataobject的来自CLargetObject类的指针各数。也就是说，总共有多少CLargeObject的object正在引用着当前的CDataobject。

class CLargeObject 
{ 
private: 
    struct CData 
    { 
    private: 
        intm_nVal; 
        intm_nReferenceCount; 
    } 
};

对于每个CLargeObject的object，我们用一个CData类的指针来指向其数据。 
CData *m_pData;

CLargeObject至少有两个构造函数。第一个是标准的构造函数，初始化其数据。这时数据是唯一的，所以必须新生成一个CData的object来存储数据。 
CLargeObject::CLargeObject(int nVal) 
{ 
    m_pData = new Data(nVal); 
} 
而对于CData类的构造函数而言，初始化他的CLargeObject是第一个指向他的，这一时刻索引数目m_nReferenceCount是1。 
CLargeObject::Data::Data(int nVal) : m_nVal(nVal),m_nReferenceCount(1) {}

CLargeObject的第二个构造函数是拷贝构造(copy constructor)。这样生成的object不需要有新的数据，和已有的object共享数据就可以了。这是索引数目需要加1。表示又有一个object指向当前的CData了。 
CLargeObject::CLargeObject(const CLargeObject &ob) //copy constructor 
{ 
   ob.m_pData->m_nReferenceCount++; 
    m_pData = ob.m_pData; 
}

这样CLargeObject就构造好了，使用了可能的最少的内存。下面看看他的析够函数(destructor)。当一个object被delete的时候，它的数据不一定无效，如果别的object还在引用着这个数据，数据需要留下来。当然，数据的索引数目无论如何都要减1。 
CLargeObject::~CLargeObject() 
{ 
    if (--m_pData->m_nReferenceCount ==0) 
        deletem_pData; 
}

下面看一看赋值操作。先说用已有的CLargeObject赋值给这个CLargeObject。这时当前CLargeObject里面的数据要指向已有的这个object，就搞定了。 
CLargeObject& CLargeObject::operator = (constCLargeObject& ob)    // copy assignment 
{ 
   ob.m_pData->m_nReferenceCount++; 
    if (--m_pData->m_nReferenceCount ==0) 
        deletem_pData; 
    m_pData = ob.m_pData;

return *this; 
}

再来看看如何对CLargeObject里面的数据进行真正的修改。这样就一定需要对当前的object独立操作了，否则就影响到了其它指向同一块数据的CLargeObject。这样CData类需要一个新的函数，生成只用于当前CLargetObject的数据。如果当前的引用数目是1，那么当然这个CData就是只用于这个CLargeObject的了。否则就重新new一个CData返回。 
        Data*CLargeObject::CData::get_own_copy()    // clone ifnecessary 
        { 
           if (m_nReferenceCount==1) 
               return this; 
           m_nReferenceCount--; 
           return new Data(m_nVal); 
        } 
CLargeObject修改前用这个函数得到唯一的object，然后对它赋值。 
void CLargeObject::SetVal(int nNewVal) 
{ 
    m_pData =m_pData->get_own_copy(); 
    m_pData->m_nVal = nNewVal; 
} 
对于所有可能改变CData值的操作，都需要用这种方法。

下面是只读函数，简单。直接返回值，什么特殊的都不用作。 
int CLargeObject::GetVal() const 
{ 
    return m_pData->m_nVal; 
}

这样copy-to-write技术就实现了。下面把完整的程序写一下： 
class CLargeObject 
{ 
public: 
    CLargeObject(int nVal); 
    CLargeObject(const CLargeObject&ob); 
    ~CLargeObject();

CLargeObject& operator = (constCLargeObject& ob); 
    void SetVal(int nNewVal); 
    int GetVal() const; 
private: 
    struct Data 
    { 
    public: 
        Data(int nVal): m_nVal(nVal), m_nReferenceCount(1) {} 
    private: 
        friend classCLargeObject; 
        Data*get_own_copy()    // clone if necessary 
        { 
           if (m_nReferenceCount==1) 
               return this; 
           m_nReferenceCount--; 
           return new Data(m_nVal); 
        }

// controlvariables. 
        intm_nReferenceCount; 
    
        // actual dataportion 
        intm_nVal; 
    };

Data *m_pData; 
};

CLargeObject::CLargeObject(int nVal) 
{ 
    m_pData = new Data(nVal); 
}

CLargeObject::CLargeObject(const CLargeObject &ob) //copy constructor 
{ 
    ob.m_pData->m_nReferenceCount++; 
    m_pData = ob.m_pData; 
}

CLargeObject::~CLargeObject() 
{ 
    if (--m_pData->m_nReferenceCount ==0) 
        deletem_pData; 
}

CLargeObject& CLargeObject::operator = (constCLargeObject& ob)    // copy assignment 
{ 
    ob.m_pData->m_nReferenceCount++; 
    if (--m_pData->m_nReferenceCount ==0) 
        deletem_pData; 
    m_pData = ob.m_pData;

return *this; 
}

void CLargeObject::SetVal(int nNewVal) 
{ 
    m_pData =m_pData->get_own_copy(); 
    m_pData->m_nVal = nNewVal; 
}

int CLargeObject::GetVal() const                                                            
{ 
    return m_pData->m_nVal; 
}

很多存储数据的系统class，如string，CString等都有这种设计。所以记住这个应用是很有必要的。

（三）C++智能指针的详细介绍和分析

*****************本部分内容摘自CSDN博客http://blog.csdn.net/hackbuteer1/article/details/7561235***************

智能指针(smart pointer)是存储指向动态分配（堆）对象指针的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。
    智能指针就是模拟指针动作的类。所有的智能指针都会重载 -> 和 * 操作符。智能指针还有许多其他功能，比较有用的是自动销毁。这主要是利用栈对象的有限作用域以及临时对象（有限作用域实现）析构函数释放内存。当然，智能指针还不止这些，还包括复制时可以修改源对象等。智能指针根据需求不同，设计也不同（写时复制，赋值即释放对象拥有权限、引用计数等，控制权转移等）。auto_ptr 即是一种常见的智能指针。
     智能指针通常用类模板实现：

[cpp] view plaincopy

1. template <class T>
2. class smartpointer
3. {
4. private:
5. T *_ptr;
6. public:
7. smartpointer(T *p) : _ptr(p)  //构造函数
8. {
9. }
10. T& operator *()        //重载*操作符
11. {
12. return *_ptr;
13. }
14. T* operator ->()       //重载->操作符
15. {
16. return _ptr;
17. }
18. ~smartpointer()        //析构函数
19. {
20. delete _ptr;
21. }
22. };

实现引用计数有两种经典策略，在这里将使用其中一种，这里所用的方法中，需要定义一个单独的具体类用以封装引用计数和相关指针：

[cpp] view plaincopy

1. // 定义仅由HasPtr类使用的U_Ptr类，用于封装使用计数和相关指针
2. // 这个类的所有成员都是private，我们不希望普通用户使用U_Ptr类，所以它没有任何public成员
3. // 将HasPtr类设置为友元，使其成员可以访问U_Ptr的成员
4. class U_Ptr
5. {
6. friend class HasPtr;
7. int *ip;
8. size_t use;
9. U_Ptr(int *p) : ip(p) , use(1)
10. {
11. cout << "U_ptr constructor called !" << endl;
12. }
13. ~U_Ptr()
14. {
15. delete ip;
16. cout << "U_ptr distructor called !" << endl;
17. }
18. };

HasPtr类需要一个析构函数来删除指针。但是，析构函数不能无条件的删除指针。”
      条件就是引用计数。如果该对象被两个指针所指，那么删除其中一个指针，并不会调用该指针的析构函数，因为此时还有另外一个指针指向该对象。看来，智能指针主要是预防不当的析构行为，防止出现悬垂指针。

如上图所示，HasPtr就是智能指针，U_Ptr为计数器；里面有个变量use和指针ip，use记录了*ip对象被多少个HasPtr对象所指。假设现在又两个HasPtr对象p1、p2指向了U_Ptr，那么现在我delete  p1，use变量将自减1，  U_Ptr不会析构，那么U_Ptr指向的对象也不会析构，那么p2仍然指向了原来的对象，而不会变成一个悬空指针。当delete p2的时候，use变量将自减1，为0。此时，U_Ptr对象进行析构，那么U_Ptr指向的对象也进行析构，保证不会出现内存泄露。 
    包含指针的类需要特别注意复制控制，原因是复制指针时只复制指针中的地址，而不会复制指针指向的对象。
    大多数C++类用三种方法之一管理指针成员
    （1）不管指针成员。复制时只复制指针，不复制指针指向的对象。当其中一个指针把其指向的对象的空间释放后，其它指针都成了悬浮指针。这是一种极端
    （2）当复制的时候，即复制指针，也复制指针指向的对象。这样可能造成空间的浪费。因为指针指向的对象的复制不一定是必要的。
   （3） 第三种就是一种折中的方式。利用一个辅助类来管理指针的复制。原来的类中有一个指针指向辅助类，辅助类的数据成员是一个计数器和一个指针（指向原来的）（此为本次智能指针实现方式）。
     其实，智能指针的引用计数类似于java的垃圾回收机制：java的垃圾的判定很简答，如果一个对象没有引用所指，那么该对象为垃圾。系统就可以回收了。
     HasPtr 智能指针的声明如下，保存一个指向U_Ptr对象的指针，U_Ptr对象指向实际的int基础对象，代码如下：

[cpp] view plaincopy

1. #include<iostream>
2. using namespace std;
3. // 定义仅由HasPtr类使用的U_Ptr类，用于封装使用计数和相关指针
4. // 这个类的所有成员都是private，我们不希望普通用户使用U_Ptr类，所以它没有任何public成员
5. // 将HasPtr类设置为友元，使其成员可以访问U_Ptr的成员
6. class U_Ptr
7. {
8. friend class HasPtr;
9. int *ip;
10. size_t use;
11. U_Ptr(int *p) : ip(p) , use(1)
12. {
13. cout << "U_ptr constructor called !" << endl;
14. }
15. ~U_Ptr()
16. {
17. delete ip;
18. cout << "U_ptr distructor called !" << endl;
19. }
20. };
21. class HasPtr
22. {
23. public:
24. // 构造函数：p是指向已经动态创建的int对象指针
25. HasPtr(int *p, int i) : ptr(new U_Ptr(p)) , val(i)
26. {
27. cout << "HasPtr constructor called ! " << "use = " << ptr->use << endl;
28. }
29. // 复制构造函数：复制成员并将使用计数加1
30. HasPtr(const HasPtr& orig) : ptr(orig.ptr) , val(orig.val)
31. {
32. ++ptr->use;
33. cout << "HasPtr copy constructor called ! " << "use = " << ptr->use << endl;
34. }
35. // 赋值操作符
36. HasPtr& operator=(const HasPtr&);
37. // 析构函数：如果计数为0，则删除U_Ptr对象
38. ~HasPtr()
39. {
40. cout << "HasPtr distructor called ! " << "use = " << ptr->use << endl;
41. if (--ptr->use == 0)
42. delete ptr;
43. }
44. // 获取数据成员
45. int *get_ptr() const
46. {
47. return ptr->ip;
48. }
49. int get_int() const
50. {
51. return val;
52. }
53. // 修改数据成员
54. void set_ptr(int *p) const
55. {
56. ptr->ip = p;
57. }
58. void set_int(int i)
59. {
60. val = i;
61. }
62. // 返回或修改基础int对象
63. int get_ptr_val() const
64. {
65. return *ptr->ip;
66. }
67. void set_ptr_val(int i)
68. {
69. *ptr->ip = i;
70. }
71. private:
72. U_Ptr *ptr;   //指向使用计数类U_Ptr
73. int val;
74. };
75. HasPtr& HasPtr::operator = (const HasPtr &rhs)  //注意，这里赋值操作符在减少做操作数的使用计数之前使rhs的使用技术加1，从而防止自我赋值
76. {
77. // 增加右操作数中的使用计数
78. ++rhs.ptr->use;
79. // 将左操作数对象的使用计数减1，若该对象的使用计数减至0，则删除该对象
80. if (--ptr->use == 0)
81. delete ptr;
82. ptr = rhs.ptr;   // 复制U_Ptr指针
83. val = rhs.val;   // 复制int成员
84. return *this;
85. }
86. int main(void)
87. {
88. int *pi = new int(42);
89. HasPtr *hpa = new HasPtr(pi, 100);    // 构造函数
90. HasPtr *hpb = new HasPtr(*hpa);     // 拷贝构造函数
91. HasPtr *hpc = new HasPtr(*hpb);     // 拷贝构造函数
92. HasPtr hpd = *hpa;     // 拷贝构造函数
93. cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;
94. hpc->set_ptr_val(10000);
95. cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;
96. hpd.set_ptr_val(10);
97. cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;
98. delete hpa;
99. delete hpb;
100. delete hpc;
101. cout << hpd.get_ptr_val() << endl;
102. return 0;
103. }

这里的赋值操作符比较麻烦，且让我用图表分析一番：
假设现在又两个智能指针p1、 p2，一个指向内容为42的内存，一个指向内容为100的内存，如下图：

现在，我要做赋值操作，p2 = p1。对比着上面的

[cpp] view plaincopy

1. HasPtr& operator=(const HasPtr&);   // 赋值操作符

此时，rhs就是p1，首先将p1指向的ptr的use加1，

[cpp] view plaincopy

1. ++rhs.ptr->use;     // 增加右操作数中的使用计数

然后，做：

[cpp] view plaincopy

1. if (--ptr->use == 0)
2. delete ptr;

因为，原先p2指向的对象现在p2不在指向，那么该对象就少了一个指针去指，所以，use做自减1；
此时，条件成立。因为u2的use为1。那么，运行U_Ptr的析构函数，而在U_Ptr的析构函数中，做了delete ip操作，所以释放了内存，不会有内存泄露的问题。
接下来的操作很自然，无需多言：

[cpp] view plaincopy

1. ptr = rhs.ptr;   // 复制U_Ptr指针
2. val = rhs.val;   // 复制int成员
3. return *this;

做完赋值操作后，那么就成为如下图所示了。红色标注的就是变化的部分：

而还要注意的是，重载赋值操作符的时候，一定要注意的是，检查自我赋值的情况。
如图所示：

此时，做p1 = p1的操作。那么，首先u1.use自增1，为2；然后，u1.use自减1，为1。那么就不会执行delete操作，剩下的操作都可以顺利进行。按《C++ primer》说法，“这个赋值操作符在减少左操作数的使用计数之前使rhs的使用计数加1，从而防止自身赋值”。哎，反正我是那样理解的。当然，赋值操作符函数中一来就可以按常规那样：

[cpp] view plaincopy

1. if(this == &rhs)
2. return *this;

运行结果如下图：

（四）对STL智能指针类auto_ptr的分析

*******************本部分内容摘自开源中国社区http://my.oschina.net/chen106106/blog/45680*********************

98 C++标准只规定了一个智能指针,就是 
template <class Type> 
class auto_ptr 
    下面是示例代码： 
#include <memory> 
using namespace std;

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    auto_ptr<string> spString(newstring("hello,world")); 
    size_t length=spString->length(); 
    return 0; 
} 
    模板参数Type是auto_ptr管理的类型，auto_ptr<string>的构造函数接受类型为string*的指针，析构函数将用delete释放该指针。 
    auto_ptr模板类提供了get函数用来获得裸指针T*，也可以通过reset来重新接受一个新的指针，同时释放内部的指针。 
    auto_ptr模板类提供了operator ->用来模仿指针的调用函数行为，提供了operator*用来模仿指针的间接引用功能。 
    如果想手动回收指针，可以调用release函数，该函数将返回内部管理的裸指针并且 
内部成员置为0。 
    auto_ptr经过专门的设计，使它拥有一个奇特的功能，所有权转移，也是很多人的烦恼之源。下面是所有权转移导致的几种烦恼： 
    1）auto_ptr不能用于STL容器，这是因为当我们使用像sort这样的函数对容器排序时，该函数内部会创建auto_ptr的副本，所有权转移到副本上，而容器中的auto_ptr元素已经不再管理原来的指针，所以这是错误的用法。大部分的auto_ptr的实现中将拷贝构造函数和拷贝赋值函数的参数故意定为非常量引用，而大多数容器插入函数都接受常量引用，所以，像下面的代码，通常是不能编译通过的。 
    vector<auto_ptr<char> > v; 
    auto_ptr<char> spBuffer(new char[100]); 
    v.push_back(spBuffer); 
    2）如果你使用auto_ptr来管理你的成员指针，小心的处理对象拷贝机制

class A 
{ 
public: 
    A(string const& str):_spStr(new string(str)) 
    { 
    }

private: 
    auto_ptr<string> _spStr; 
};

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    string str("hello,world"); 
    A a1(str); 
    A a2(a1); 
    return 0; 
} 
    当A a2(a1)执行后，a2._spStr将拥有指针所有权，而a1._spStr将释放指针所有权，这可能是你不想要的情况。你可以将拷贝构造函数和拷贝赋值函数禁止，或者提供自己的深拷贝版本，或者使用const auto_ptr作为成员变量，因为const auto_ptr不可被拷贝，也就不可能失去所有权。

class A 
{ 
public: 
    A(){} 
    A(string const& str):_spStr(new string(str)) 
    { 
    } 
    A(A const& rhs):_spStr(newstring(*rhs._spStr)) 
    { 
         
    } 
    A& operator = (A const& rhs) 
    { 
        if(this!=&rhs) 
        { 
            _spStr.reset(newstring(*rhs._spStr)); 
        } 
        return *this; 
    } 
private: 
    auto_ptr<string> _spStr; 
};

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    string str("hello,world"); 
    A a1(str); 
    A a2; 
    a2=a1; 
    return 0; 
}

使用auto_ptr const 成员 
class A 
{ 
public: 
    A(){} 
    A(string const& str):_spStr(new string(str)) 
    { 
    }

private: 
    auto_ptr<string> const _spStr; 
};

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    string str("hello,world"); 
    A a1(str); 
    A a2(a1); 
    return 0; 
} 
error C2558: class 'std::auto_ptr<_Ty>' : no copy constructoravailable or copy constructor is declared 'explicit'

另外，由于auto_ptr在析构函数中使用delete语句而不是delete[]，所以auto_ptr不能用于包装指向数组的指针，除非包装的是预定义类型。因为 
char* p=new char[100]; 
... 
delete p; 
是可以的，所以你可以使用： 
auto_ptr<char> sp(new char[100]()); 
... 
    所有权转移也会给我们带来一些好东西。比如： 
string* F1() 
{ 
    return new string("hello,world"); 
}

auto_ptr<string> F2() 
{ 
    return auto_ptr<string>(newstring("hello,world")); 
}

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    string* p=F1(); 
    auto_ptr<string> sp=F2(); 
    return 0; 
}

如果忽略了这两个函数的返回值，F1返回的指针将再也找不到，内存泄漏，F2会返回临时变量，并且会被安全的释放掉，没有内存泄漏。并且当F2函数较为复杂时，返回auto_ptr提升了异常安全性。异常安全性将在后面介绍。

addingW,��tmp���dding-left: 1px; margin-top: 0px; margin-right: 10px; margin-bottom: 0px; margin-left: 0px; font-size: 9px; display: inline-block; width: 16px; height: 16px; text-indent: -2000px; background-position: 0% 0%; background-repeat: no-repeat no-repeat; ">copy

 

1. if (--ptr->use == 0)
2. delete ptr;

因为，原先p2指向的对象现在p2不在指向，那么该对象就少了一个指针去指，所以，use做自减1；
此时，条件成立。因为u2的use为1。那么，运行U_Ptr的析构函数，而在U_Ptr的析构函数中，做了delete ip操作，所以释放了内存，不会有内存泄露的问题。
接下来的操作很自然，无需多言：

[cpp] view plaincopy

 

1. ptr = rhs.ptr;   // 复制U_Ptr指针
2. val = rhs.val;   // 复制int成员
3. return *this;

做完赋值操作后，那么就成为如下图所示了。红色标注的就是变化的部分：

而还要注意的是，重载赋值操作符的时候，一定要注意的是，检查自我赋值的情况。
如图所示：

此时，做p1 = p1的操作。那么，首先u1.use自增1，为2；然后，u1.use自减1，为1。那么就不会执行delete操作，剩下的操作都可以顺利进行。按《C++ primer》说法，“这个赋值操作符在减少左操作数的使用计数之前使rhs的使用计数加1，从而防止自身赋值”。哎，反正我是那样理解的。当然，赋值操作符函数中一来就可以按常规那样：

[cpp] view plaincopy

 

1. if(this == &rhs)
2. return *this;

运行结果如下图：

（四）对STL智能指针类auto_ptr的分析

*******************本部分内容摘自开源中国社区http://my.oschina.net/chen106106/blog/45680*********************

98 C++标准只规定了一个智能指针,就是 
template <class Type> 
class auto_ptr 
    下面是示例代码： 
#include <memory> 
using namespace std;

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    auto_ptr<string> spString(new string("hello,world")); 
    size_t length=spString->length(); 
    return 0; 
} 
    模板参数Type是auto_ptr管理的类型，auto_ptr<string>的构造函数接受类型为string*的指针，析构函数将用delete释放该指针。 
    auto_ptr模板类提供了get函数用来获得裸指针T*，也可以通过reset来重新接受一个新的指针，同时释放内部的指针。 
    auto_ptr模板类提供了operator ->用来模仿指针的调用函数行为，提供了operator*用来模仿指针的间接引用功能。 
    如果想手动回收指针，可以调用release函数，该函数将返回内部管理的裸指针并且 
内部成员置为0。 
    auto_ptr经过专门的设计，使它拥有一个奇特的功能，所有权转移，也是很多人的烦恼之源。下面是所有权转移导致的几种烦恼： 
    1）auto_ptr不能用于STL容器，这是因为当我们使用像sort这样的函数对容器排序时，该函数内部会创建auto_ptr的副本，所有权转移到副本上，而容器中的auto_ptr元素已经不再管理原来的指针，所以这是错误的用法。大部分的auto_ptr的实现中将拷贝构造函数和拷贝赋值函数的参数故意定为非常量引用，而大多数容器插入函数都接受常量引用，所以，像下面的代码，通常是不能编译通过的。 
    vector<auto_ptr<char> > v; 
    auto_ptr<char> spBuffer(new char[100]); 
    v.push_back(spBuffer); 
    2）如果你使用auto_ptr来管理你的成员指针，小心的处理对象拷贝机制

class A 
{ 
public: 
    A(string const& str):_spStr(new string(str)) 
    { 
    }

private: 
    auto_ptr<string> _spStr; 
};

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    string str("hello,world"); 
    A a1(str); 
    A a2(a1); 
    return 0; 
} 
    当A a2(a1)执行后，a2._spStr将拥有指针所有权，而a1._spStr将释放指针所有权，这可能是你不想要的情况。你可以将拷贝构造函数和拷贝赋值函数禁止，或者提供自己的深拷贝版本，或者使用const auto_ptr作为成员变量，因为const auto_ptr不可被拷贝，也就不可能失去所有权。

class A 
{ 
public: 
    A(){} 
    A(string const& str):_spStr(new string(str)) 
    { 
    } 
    A(A const& rhs):_spStr(new string(*rhs._spStr)) 
    { 
         
    } 
    A& operator = (A const& rhs) 
    { 
        if(this!=&rhs) 
        { 
            _spStr.reset(new string(*rhs._spStr)); 
        } 
        return *this; 
    } 
private: 
    auto_ptr<string> _spStr; 
};

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    string str("hello,world"); 
    A a1(str); 
    A a2; 
    a2=a1; 
    return 0; 
}

使用auto_ptr const 成员 
class A 
{ 
public: 
    A(){} 
    A(string const& str):_spStr(new string(str)) 
    { 
    }

private: 
    auto_ptr<string> const _spStr; 
};

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    string str("hello,world"); 
    A a1(str); 
    A a2(a1); 
    return 0; 
} 
error C2558: class 'std::auto_ptr<_Ty>' : no copy constructor available or copy constructor is declared 'explicit'

另外，由于auto_ptr在析构函数中使用delete语句而不是delete[]，所以auto_ptr不能用于包装指向数组的指针，除非包装的是预定义类型。因为 
char* p=new char[100]; 
... 
delete p; 
是可以的，所以你可以使用： 
auto_ptr<char> sp(new char[100]()); 
... 
    所有权转移也会给我们带来一些好东西。比如： 
string* F1() 
{ 
    return new string("hello,world"); 
}

auto_ptr<string> F2() 
{ 
    return auto_ptr<string>(new string("hello,world")); 
}

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    string* p=F1(); 
    auto_ptr<string> sp=F2(); 
    return 0; 
}

如果忽略了这两个函数的返回值，F1返回的指针将再也找不到，内存泄漏，F2会返回临时变量，并且会被安全的释放掉，没有内存泄漏。并且当F2函数较为复杂时，返回auto_ptr提升了异常安全性。异常安全性将在后面介绍。

（五）对C++智能指针的又一分析

*************本部分内容转自http://mxdxm.iteye.com/blog/763601********************************

一、简介

由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，最终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。

用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: intrusive_ptr。你可能会想，如此多的智能指针就为了解决new、delete匹配问题，真的有必要吗？看完这篇文章后，我想你心里自然会有答案。

下面就按照顺序讲解如上 7 种智能指针（smart_ptr）。

二、具体使用

1、总括

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

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

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

我们编写一个测试类来辅助分析：

class Simple {

public:

Simple(int param = 0) {

number = param;

std::cout << "Simple: " << number << std::endl;

}

~Simple() {

std::cout << "~Simple: " << number << std::endl;

}

void PrintSomething() {

std::cout << "PrintSomething: " << info_extend.c_str() << std::endl;

}

std::string info_extend;

int number;

};

2、std::auto_ptr

std::auto_ptr 属于 STL，当然在 namespace std 中，包含头文件 #include<memory> 便可以使用。std::auto_ptr 能够方便的管理单个堆内存对象。

我们从代码开始分析：

void TestAutoPtr() {

std::auto_ptr<Simple> my_memory(new Simple(1));   // 创建对象，输出：Simple：1

if (my_memory.get()) {                            // 判断智能指针是否为空

my_memory->PrintSomething();                    // 使用 operator-> 调用智能指针对象中的函数

my_memory.get()->info_extend = "Addition";      // 使用 get() 返回裸指针，然后给内部对象赋值

my_memory->PrintSomething();                    // 再次打印，表明上述赋值成功

(*my_memory).info_extend += " other";           // 使用 operator* 返回智能指针内部对象，然后用“.”调用智能指针对象中的函数

my_memory->PrintSomething();                    // 再次打印，表明上述赋值成功

}

}                                                   // my_memory 栈对象即将结束生命期，析构堆对象 Simple(1)

执行结果为：

Simple: 1

PrintSomething:

PrintSomething: Addition

PrintSomething: Addition other

~Simple: 1

上述为正常使用 std::auto_ptr 的代码，一切似乎都良好，无论如何不用我们显示使用该死的 delete 了。

其实好景不长，我们看看如下的另一个例子：

void TestAutoPtr2() {

std::auto_ptr<Simple> my_memory(new Simple(1));

if (my_memory.get()) {

std::auto_ptr<Simple> my_memory2;   // 创建一个新的 my_memory2 对象

my_memory2 = my_memory;             // 复制旧的 my_memory 给 my_memory2

my_memory2->PrintSomething();       // 输出信息，复制成功

my_memory->PrintSomething();        // 崩溃

}

}

最终如上代码导致崩溃，如上代码时绝对符合 C++ 编程思想的，居然崩溃了，跟进 std::auto_ptr 的源码后，我们看到，罪魁祸首是“my_memory2 = my_memory”，这行代码，my_memory2 完全夺取了 my_memory 的内存管理所有权，导致 my_memory 悬空，最后使用时导致崩溃。

所以，使用 std::auto_ptr 时，绝对不能使用“operator=”操作符。作为一个库，不允许用户使用，确没有明确拒绝[1]，多少会觉得有点出乎预料。

看完 std::auto_ptr 好景不长的第一个例子后，让我们再来看一个：

void TestAutoPtr3() {

std::auto_ptr<Simple> my_memory(new Simple(1));

if (my_memory.get()) {

my_memory.release();

}

}

执行结果为：

Simple: 1

看到什么异常了吗？我们创建出来的对象没有被析构，没有输出“~Simple: 1”，导致内存泄露。当我们不想让 my_memory 继续生存下去，我们调用 release() 函数释放内存，结果却导致内存泄露（在内存受限系统中，如果my_memory占用太多内存，我们会考虑在使用完成后，立刻归还，而不是等到 my_memory 结束生命期后才归还）。

正确的代码应该为：

void TestAutoPtr3() {

std::auto_ptr<Simple> my_memory(new Simple(1));

if (my_memory.get()) {

Simple* temp_memory = my_memory.release();

delete temp_memory;

}

}

或

void TestAutoPtr3() {

std::auto_ptr<Simple> my_memory(new Simple(1));

if (my_memory.get()) {

my_memory.reset();  // 释放 my_memory 内部管理的内存

}

}

原来 std::auto_ptr 的 release() 函数只是让出内存所有权，这显然也不符合 C++ 编程思想。

总结：std::auto_ptr 可用来管理单个对象的对内存，但是，请注意如下几点：

（1）    尽量不要使用“operator=”。如果使用了，请不要再使用先前对象。

（2）    记住 release() 函数不会释放对象，仅仅归还所有权。

（3）    std::auto_ptr 最好不要当成参数传递（读者可以自行写代码确定为什么不能）。

（4）    由于 std::auto_ptr 的“operator=”问题，有其管理的对象不能放入 std::vector 等容器中。

（5）    ……

使用一个 std::auto_ptr 的限制还真多，还不能用来管理堆内存数组，这应该是你目前在想的事情吧，我也觉得限制挺多的，哪天一个不小心，就导致问题了。

由于 std::auto_ptr 引发了诸多问题，一些设计并不是非常符合 C++ 编程思想，所以引发了下面 boost 的智能指针，boost 智能指针可以解决如上问题。

让我们继续向下看。

3、boost::scoped_ptr

boost::scoped_ptr 属于 boost 库，定义在 namespace boost 中，包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。boost::scoped_ptr 跟 std::auto_ptr 一样，可以方便的管理单个堆内存对象，特别的是，boost::scoped_ptr 独享所有权，避免了 std::auto_ptr 恼人的几个问题。

我们还是从代码开始分析：

void TestScopedPtr() {

boost::scoped_ptr<Simple> my_memory(new Simple(1));

if (my_memory.get()) {

my_memory->PrintSomething();

my_memory.get()->info_extend = "Addition";

my_memory->PrintSomething();

(*my_memory).info_extend += " other";

my_memory->PrintSomething();

my_memory.release();           // 编译 error: scoped_ptr 没有 release 函数

std::auto_ptr<Simple> my_memory2;

my_memory2 = my_memory;        // 编译 error: scoped_ptr 没有重载 operator=，不会导致所有权转移

}

}

首先，我们可以看到，boost::scoped_ptr 也可以像 auto_ptr 一样正常使用。但其没有 release() 函数，不会导致先前的内存泄露问题。其次，由于 boost::scoped_ptr 是独享所有权的，所以明确拒绝用户写“my_memory2 = my_memory”之类的语句，可以缓解 std::auto_ptr 几个恼人的问题。

由于 boost::scoped_ptr 独享所有权，当我们真真需要复制智能指针时，需求便满足不了了，如此我们再引入一个智能指针，专门用于处理复制，参数传递的情况，这便是如下的 boost::shared_ptr。

4、boost::shared_ptr

boost::shared_ptr 属于 boost 库，定义在 namespace boost 中，包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。在上面我们看到 boost::scoped_ptr 独享所有权，不允许赋值、拷贝，boost::shared_ptr 是专门用于共享所有权的，由于要共享所有权，其在内部使用了引用计数。boost::shared_ptr 也是用于管理单个堆内存对象的。

我们还是从代码开始分析：

void TestSharedPtr(boost::shared_ptr<Simple> memory) {  // 注意：无需使用 reference (或 const reference)

memory->PrintSomething();

std::cout << "TestSharedPtr UseCount: " << memory.use_count() << std::endl;

}

void TestSharedPtr2() {

boost::shared_ptr<Simple> my_memory(new Simple(1));

if (my_memory.get()) {

my_memory->PrintSomething();

my_memory.get()->info_extend = "Addition";

my_memory->PrintSomething();

(*my_memory).info_extend += " other";

my_memory->PrintSomething();

}

std::cout << "TestSharedPtr2 UseCount: " << my_memory.use_count() << std::endl;

TestSharedPtr(my_memory);

std::cout << "TestSharedPtr2 UseCount: " << my_memory.use_count() << std::endl;

//my_memory.release();// 编译 error: 同样，shared_ptr 也没有 release 函数

}

执行结果为：

Simple: 1

PrintSomething:

PrintSomething: Addition

PrintSomething: Addition other

TestSharedPtr2 UseCount: 1

PrintSomething: Addition other

TestSharedPtr UseCount: 2

TestSharedPtr2 UseCount: 1

~Simple: 1

boost::shared_ptr 也可以很方便的使用。并且没有 release() 函数。关键的一点，boost::shared_ptr 内部维护了一个引用计数，由此可以支持复制、参数传递等。boost::shared_ptr 提供了一个函数 use_count() ，此函数返回 boost::shared_ptr 内部的引用计数。查看执行结果，我们可以看到在 TestSharedPtr2 函数中，引用计数为 1，传递参数后（此处进行了一次复制），在函数TestSharedPtr 内部，引用计数为2，在 TestSharedPtr 返回后，引用计数又降低为 1。当我们需要使用一个共享对象的时候，boost::shared_ptr 是再好不过的了。

在此，我们已经看完单个对象的智能指针管理，关于智能指针管理数组，我们接下来讲到。

5、boost::scoped_array

boost::scoped_array 属于 boost 库，定义在 namespace boost 中，包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。

boost::scoped_array 便是用于管理动态数组的。跟 boost::scoped_ptr 一样，也是独享所有权的。

我们还是从代码开始分析：

void TestScopedArray() {

boost::scoped_array<Simple> my_memory(new Simple[2]); // 使用内存数组来初始化

if (my_memory.get()) {

my_memory[0].PrintSomething();

my_memory.get()[0].info_extend = "Addition";

my_memory[0].PrintSomething();

(*my_memory)[0].info_extend += " other";            // 编译 error，scoped_ptr 没有重载 operator*

my_memory[0].release();                             // 同上，没有 release 函数

boost::scoped_array<Simple> my_memory2;

my_memory2 = my_memory;                             // 编译 error，同上，没有重载 operator=

}

}

boost::scoped_array 的使用跟 boost::scoped_ptr 差不多，不支持复制，并且初始化的时候需要使用动态数组。另外，boost::scoped_array 没有重载“operator*”，其实这并无大碍，一般情况下，我们使用 get() 函数更明确些。

下面肯定应该讲 boost::shared_array 了，一个用引用计数解决复制、参数传递的智能指针类。

6、boost::shared_array

boost::shared_array 属于 boost 库，定义在 namespace boost 中，包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。

由于 boost::scoped_array 独享所有权，显然在很多情况下（参数传递、对象赋值等）不满足需求，由此我们引入 boost::shared_array。跟 boost::shared_ptr 一样，内部使用了引用计数。

我们还是从代码开始分析：

void TestSharedArray(boost::shared_array<Simple> memory) {  // 注意：无需使用 reference (或 const reference)

std::cout << "TestSharedArray UseCount: " << memory.use_count() << std::endl;

}

void TestSharedArray2() {

boost::shared_array<Simple> my_memory(new Simple[2]);

if (my_memory.get()) {

my_memory[0].PrintSomething();

my_memory.get()[0].info_extend = "Addition 00";

my_memory[0].PrintSomething();

my_memory[1].PrintSomething();

my_memory.get()[1].info_extend = "Addition 11";

my_memory[1].PrintSomething();

//(*my_memory)[0].info_extend += " other";  // 编译 error，scoped_ptr 没有重载 operator*

}

std::cout << "TestSharedArray2 UseCount: " << my_memory.use_count() << std::endl;

TestSharedArray(my_memory);

std::cout << "TestSharedArray2 UseCount: " << my_memory.use_count() << std::endl;

}

执行结果为：

Simple: 0

Simple: 0

PrintSomething:

PrintSomething: Addition 00

PrintSomething:

PrintSomething: Addition 11

TestSharedArray2 UseCount: 1

TestSharedArray UseCount: 2

TestSharedArray2 UseCount: 1

~Simple: 0

~Simple: 0

跟 boost::shared_ptr 一样，使用了引用计数，可以复制，通过参数来传递。

至此，我们讲过的智能指针有 std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array。这几个智能指针已经基本够我们使用了，90% 的使用过标准智能指针的代码就这 5 种。可如下还有两种智能指针，它们肯定有用，但有什么用处呢，一起看看吧。

7、boost::weak_ptr

boost::weak_ptr 属于 boost 库，定义在 namespace boost 中，包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。

在讲 boost::weak_ptr 之前，让我们先回顾一下前面讲解的内容。似乎 boost::scoped_ptr、boost::shared_ptr 这两个智能指针就可以解决所有单个对象内存的管理了，这儿还多出一个 boost::weak_ptr，是否还有某些情况我们没纳入考虑呢？

回答：有。首先 boost::weak_ptr 是专门为 boost::shared_ptr 而准备的。有时候，我们只关心能否使用对象，并不关心内部的引用计数。boost::weak_ptr 是 boost::shared_ptr 的观察者（Observer）对象，观察者意味着 boost::weak_ptr 只对 boost::shared_ptr 进行引用，而不改变其引用计数，当被观察的 boost::shared_ptr 失效后，相应的 boost::weak_ptr 也相应失效。

我们还是从代码开始分析：

void TestWeakPtr() {

boost::weak_ptr<Simple> my_memory_weak;

boost::shared_ptr<Simple> my_memory(new Simple(1));

std::cout << "TestWeakPtr boost::shared_ptr UseCount: " << my_memory.use_count() << std::endl;

my_memory_weak = my_memory;

std::cout << "TestWeakPtr boost::shared_ptr UseCount: " << my_memory.use_count() << std::endl;

}

执行结果为：

Simple: 1

TestWeakPtr boost::shared_ptr UseCount: 1

TestWeakPtr boost::shared_ptr UseCount: 1

~Simple: 1

我们看到，尽管被赋值了，内部的引用计数并没有什么变化，当然，读者也可以试试传递参数等其他情况。

现在要说的问题是，boost::weak_ptr 到底有什么作用呢？从上面那个例子看来，似乎没有任何作用，其实 boost::weak_ptr 主要用在软件架构设计中，可以在基类（此处的基类并非抽象基类，而是指继承于抽象基类的虚基类）中定义一个 boost::weak_ptr，用于指向子类的 boost::shared_ptr，这样基类仅仅观察自己的 boost::weak_ptr 是否为空就知道子类有没对自己赋值了，而不用影响子类 boost::shared_ptr 的引用计数，用以降低复杂度，更好的管理对象。

8、boost::intrusive_ptr

boost::intrusive_ptr属于 boost 库，定义在 namespace boost 中，包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。

讲完如上 6 种智能指针后，对于一般程序来说 C++ 堆内存管理就够用了，现在有多了一种 boost::intrusive_ptr，这是一种插入式的智能指针，内部不含有引用计数，需要程序员自己加入引用计数，不然编译不过（⊙﹏⊙b汗）。个人感觉这个智能指针没太大用处，至少我没用过。有兴趣的朋友自己研究一下源代码哦J。

三、总结

如上讲了这么多智能指针，有必要对这些智能指针做个总结：

1、在可以使用 boost 库的场合下，拒绝使用 std::auto_ptr，因为其不仅不符合 C++ 编程思想，而且极容易出错[2]。

2、在确定对象无需共享的情况下，使用 boost::scoped_ptr（当然动态数组使用 boost::scoped_array）。

3、在对象需要共享的情况下，使用 boost::shared_ptr（当然动态数组使用 boost::shared_array）。

4、在需要访问 boost::shared_ptr 对象，而又不想改变其引用计数的情况下，使用 boost::weak_ptr，一般常用于软件框架设计中。

5、最后一点，也是要求最苛刻一点：在你的代码中，不要出现 delete 关键字（或 C 语言的 free 函数），因为可以用智能指针去管理。