智能指针的设计初衷是：

     C++中没有提供自己主动回收内存的机制，每次new对象之后都须要手动delete。稍不注意就memory leak。

智能指针能够解决上面遇到的问题。

C++中常见的智能指针包含(共七种)：

     std::auto_ptr

     boost::scoped_ptr

     boost::shared_ptr

     boost::intrusive_ptr

     boost::scoped_array

     boost::shared_array

     boost::weak_ptr

    事实上，智能指针并非指针，它不过一个栈对象而已。

在栈对象的生命周期结束时，智能指针调用析构函数释放其管理的堆内存。

全部的智能指针都重载了'operator->'操作符，用来返回其管理对象的引用。从而能够

运行所管理对象的一些操作。

两个方法：

     - get()

          訪问智能指针包括的裸指针引用

     - reset()

          若传递參数为空或NULL 则智能指针会释放当前管理的内存。

          若传递參数为一个对象 则智能指针会释放当前管理的内存，管理新传入的对象。

假定有以下这个ManagedObj类。

class ManagedObj{public:    ManagedObj(int val = 0):m_val(val)    {        cout<<"Obj : "<
      
       <
      

-> std::auto_ptr

---

属于STL

在namespace std中

加入头文件 #include <memory>就可以使用。

auto_ptr一般用于管理单个堆内存对象。

看以下这个样例：

// std::auto_ptrvoid testAutoPtr1(){    auto_ptr
      
        atPtr(new ManagedObj(1, " initialize"));    if (atPtr.get())    // 推断智能指针是否为空    {        atPtr->testFun();        atPtr.get()->m_info += " 1st append";    // get() 返回裸指针的引用        atPtr->testFun();        (*atPtr).m_info += " 2nd append";        // operator* 返回智能指针管理的对象        (*atPtr).testFun();    }}
      

执行结果为：

OK 好像没什么问题。

我们接着測试：

void testAutoPtr2(){    auto_ptr
      
        atPtr(new ManagedObj(1, " initialize"));    if (atPtr.get())    // 推断智能指针是否为空    {        auto_ptr
       
         atPtr2;        atPtr2 = atPtr;               // 原因在这行代码        atPtr2->testFun();        atPtr->testFun();          // 崩溃在这行代码    }}
       
      

执行结果为：

调试发现 最后一行代码出bug了。

为什么呢？

事实上是atPtr2剥夺了atPtr的内存管理全部权，导致atPtr悬空。

继续測试。

void testAutoPtr3(){    auto_ptr
      
        atPtr(new ManagedObj(1, " initialize"));    if (atPtr.get())    // 推断智能指针是否为空    {        atPtr.release();    }}
      

执行结果为：

好像又出bug了。

我们并没有看到析构函数被调用的迹象，内存泄漏了。。

(逗我呢 怎么这么多bug?

)

别着急 第三个測试函数正确的写法应该是这种。

void testAutoPtr3(){    auto_ptr
      
        atPtr(new ManagedObj(1, " initialize"));    if (atPtr.get())    // 推断智能指针是否为空    {        //ManagedObj* temp = atPtr.release();        //delete temp;        // 或者        atPtr.reset();    }}
      

这才是我们想要看到的结果。

所以我们也发现。auto_ptr的release()函数仅仅是让出内存的管理权，并没有真正的释放内存。

总结：

     auto_ptr一般用于管理单个堆内存对象。

可是须要注意：

     a. 切记使用 "operator="。万一真用了，就不要再使用旧的对象了。

     b. release()方法不会释放内存 只不过让出全部权。

上面的auto_ptr使用起来确实不是非常方便，并且我们还有注意避开它的使用缺陷。

因此就出现了boost中的一些智能指针，以下一一介绍。

-> boost::scoped_ptr

---

属于boost库

在namespace boost中

加入头文件 #include<boost/smart_ptr.hpp> 就可以使用。

关于boost库的安装教程 可參考：

与auto_ptr类似。scoped_ptr也可管理单个堆内存的对象，

可是

它独享全部权，因此也就避免了auto_ptr的缺陷。

OK。上代码測试。

// boost::scoped_ptrvoid testScopedPtr(){	boost::scoped_ptr
       
         scPtr(new ManagedObj(1, " initialize"));	if (scPtr.get())	{		scPtr->testFun();		scPtr.get()->m_info += " 1st append";	// get() 返回裸指针的引用		scPtr->testFun();		(*scPtr).m_info += " 2nd append";		// operator* 返回智能指针管理的对象		(*scPtr).testFun();		//scPtr.release();				// error scoped_ptr 没有成员release				//boost::scoped_ptr
        
          scPtr2;		//scPtr2 = scPtr;					// error scoped_ptr
         
          ::operator=(const scoped_ptr
          
            &)不可訪问	}}
          
         
        
       

执行结果为：

注意凝视部分的代码。

scoped_ptr没有release()函数  屏蔽了operator=操作，

因此不会出现auto_ptr中出现的内存泄漏和崩溃问题。

但这也带来了还有一个新问题。我们无法复制智能指针。

因此出现了接下来的shared_ptr。

-> boost::shared_ptr

---

属于boost库

在namespace boost中

加入头文件 #include<boost/smart_ptr.hpp> 就可以使用。

因为scoped_ptr不同意赋值 拷贝 独享内存的全部权。

这里的shared_ptr是专门解决智能指针的内存全部权共享这个问题的。

其内部使用了引用计数。

来，測试吧。

// boost::shared_ptrvoid testSharedPtr(boost::shared_ptr
      
        ptr){    ptr->testFun();    cout<<"shared_ptr use_count: "<
       
        <
        
          shPtr(new ManagedObj(1, " initialize"));    if (shPtr.get())    {        shPtr->testFun();        shPtr.get()->m_info += " 1st append";    // get() 返回裸指针的引用        shPtr->testFun();        (*shPtr).m_info += " 2nd append";        // operator* 返回智能指针管理的对象        (*shPtr).testFun();    }    cout<<"shared_ptr1 use_count: "<
         
          <
         
        
       
      

执行结果为：

能够看到。调用testSharedPtr()函数运行了一次复制操作，智能指针内部的引用计数+1。

在该函数调用结束后，引用计数自己主动-1。

上面介绍的几种智能指针都针对单个对象的内存管理。

事实上智能指针也可管理数组，接下来介绍boost::scoped_array和boost::shared_array。

-> boost::scoped_array

---

属于boost库

在namespace boost中

加入头文件 #include<boost/smart_ptr.hpp> 就可以使用。

boost::scoped_array用于管理动态数组。也是独享全部权的。

上代码：

// boost::scoped_arrayvoid testScopedArray(){    boost::scoped_array
      
        scArr(new ManagedObj[2]);        // 动态数组初始化    if (scArr.get())    {        scArr[0].testFun();        scArr.get()[0].m_info += " [0] 1st append";        scArr[0].testFun();        //(*scArr)[0].m_info += " 2st append";    // error scoped_array没有重载operator*        //(*scArr)[0].testFun();        //scArr[0].release();                        // error scoped_array 没有成员release        boost::scoped_array
       
         scArr2;        //scArr2 = scArr;                // error operator=不可訪问 屏蔽了operator= 禁止拷贝    }}
       
      

执行结果为：

boost::scoped_array的使用和boost::scoped_ptr大致几乎相同。

都禁止拷贝 独享全部权。

注意：

     

boost::scoped_array没有重载operator*操作符

-> boost::shared_array

---

属于boost库

在namespace boost中

加入头文件 #include<boost/smart_ptr.hpp> 就可以使用。

内部使用了引用计数，解决參数传递和拷贝赋值时的问题。

以下给出代码測试：

// boost::shared_arrayvoid testSharedArray(boost::shared_array
      
        pArr){    cout<<"shared_arr use_count: "<
       
        <
        
          pTempArr;    pTempArr = pArr;    cout<<"shared_arr use_count: "<
         
          <
          
            shArr(new ManagedObj[2]);    if (shArr.get())    {        shArr[0].testFun();        shArr.get()[0].m_info += " [0] 1st append";        shArr[0].testFun();        shArr[1].testFun();        shArr.get()[0].m_info += " [1] 1st append";        shArr[1].testFun();        //(*shArr)[0].m_info += " [0] 2nd append";    // error 没有重载operator*操作符    }    cout<<"shared_arr1 use_count: "<
           
            <
           
          
         
        
       
      

执行结果为：

-> boost::weak_ptr

---

属于boost库

在namespace boost中

加入头文件 #include<boost/smart_ptr.hpp> 就可以使用。

若我们只关心是否能使用对象。而不关心内部的引用计数。

boost::weak_ptr 是 boost::shared_ptr 的观察者(Observer)对象，

意味着boost::weak_ptr仅仅对boost::shared_ptr引用。可是并不更新

其引用计数。被观察的shared_ptr失效后，weak_ptr对应也失效。

上測试代码：

// boost::weak_ptrvoid testWeakPtr(){    boost::weak_ptr
      
        wPtr;    boost::shared_ptr
       
         shPtr(new ManagedObj(1, "initialize"));    cout << "testWeakPtr boost::shared_ptr UseCount: " << shPtr.use_count() << endl;    wPtr = shPtr;    cout << "testWeakPtr boost::shared_ptr UseCount: " << shPtr.use_count() << endl;}
       
      

执行结果为：

我们发现赋值操作并没有更改引用计数。

boost::weak_ptr很多其它用于以下这样的场合：

     在基类中定义一个weak_ptr，用于观察其子类中的shared_ptr。这样基类仅仅要看自己的weak_ptr

是否为空就知道子类有没对自己赋值，而不影响子类中shared_ptr的引用计数。从而减少复杂度。更好管理对象。

-> boost::intrusive_ptr

---

属于boost库

在namespace boost中

加入头文件 #include<boost/smart_ptr.hpp> 就可以使用。

intrusive_ptr是一种插入式智能指针，其内部没有引用计数，

须要自己增加引用计数，否则会编译错误。

OK 到这儿为止，七种智能指针基本上都大致介绍完了。

參考：

http://blog.csdn.net/xt_xiaotian/article/details/5714477

完整的代码在。

#include 
     
      #include 
      
       #include 
       
        #include 
        
         			// add header file// namespace using namespace std;using namespace boost;// heap obj classclass ManagedObj{public:	ManagedObj(int val = 0, string info = "")		:m_val(val), m_info(info)	{		cout<<"Obj : "<
         
          <
          
           <
           
             atPtr(new ManagedObj(1, " initialize")); if (atPtr.get()) // 推断智能指针是否为空 { atPtr->testFun(); atPtr.get()->m_info += " 1st append"; // get() 返回裸指针的引用 atPtr->testFun(); (*atPtr).m_info += " 2nd append"; // operator* 返回智能指针管理的对象 (*atPtr).testFun(); }}void testAutoPtr2(){ auto_ptr
            
              atPtr(new ManagedObj(1, " initialize")); if (atPtr.get()) // 推断智能指针是否为空 { auto_ptr
             
               atPtr2; atPtr2 = atPtr; atPtr2->testFun(); atPtr->testFun(); }}void testAutoPtr3(){ auto_ptr
              
                atPtr(new ManagedObj(1, " initialize")); if (atPtr.get()) // 推断智能指针是否为空 { //ManagedObj* temp = atPtr.release(); //delete temp; // 或者 atPtr.reset(); }}// boost::scoped_ptrvoid testScopedPtr(){ boost::scoped_ptr
               
                 scPtr(new ManagedObj(1, " initialize")); if (scPtr.get()) { scPtr->testFun(); scPtr.get()->m_info += " 1st append"; // get() 返回裸指针的引用 scPtr->testFun(); (*scPtr).m_info += " 2nd append"; // operator* 返回智能指针管理的对象 (*scPtr).testFun(); //scPtr.release(); // error scoped_ptr 没有成员release //boost::scoped_ptr
                
                  scPtr2; //scPtr2 = scPtr; // error scoped_ptr
                 
                  ::operator=(const scoped_ptr
                  
                    &)不可訪问 }}// boost::shared_ptrvoid testSharedPtr(boost::shared_ptr
                   
                     ptr){ ptr->testFun(); cout<<"shared_ptr use_count: "<
                    
                     <
                     
                       shPtr(new ManagedObj(1, " initialize")); if (shPtr.get()) { shPtr->testFun(); shPtr.get()->m_info += " 1st append"; // get() 返回裸指针的引用 shPtr->testFun(); (*shPtr).m_info += " 2nd append"; // operator* 返回智能指针管理的对象 (*shPtr).testFun(); } cout<<"shared_ptr1 use_count: "<
                      
                       <
                       
                         scArr(new ManagedObj[2]); // 动态数组初始化 if (scArr.get()) { scArr[0].testFun(); scArr.get()[0].m_info += " [0] 1st append"; scArr[0].testFun(); //(*scArr)[0].m_info += " 2st append"; // error scoped_array没有重载operator* //(*scArr)[0].testFun(); //scArr[0].release(); // error scoped_array 没有成员release boost::scoped_array
                        
                          scArr2; //scArr2 = scArr; // error operator=不可訪问 屏蔽了operator= 禁止拷贝 }}// boost::shared_arrayvoid testSharedArray(boost::shared_array
                         
                           pArr){ cout<<"shared_arr use_count: "<
                          
                           <
                           
                             pTempArr; pTempArr = pArr; cout<<"shared_arr use_count: "<
                            
                             <
                             
                               shArr(new ManagedObj[2]); if (shArr.get()) { shArr[0].testFun(); shArr.get()[0].m_info += " [0] 1st append"; shArr[0].testFun(); shArr[1].testFun(); shArr.get()[1].m_info += " [1] 1st append"; shArr[1].testFun(); //(*shArr)[0].m_info += " [0] 2nd append"; // error 没有重载operator*操作符 } cout<<"shared_arr1 use_count: "<
                              
                               <
                               
                                 wPtr; boost::shared_ptr
                                
                                  shPtr(new ManagedObj(1, "initialize")); cout << "testWeakPtr boost::shared_ptr UseCount: " << shPtr.use_count() << endl; wPtr = shPtr; cout << "testWeakPtr boost::shared_ptr UseCount: " << shPtr.use_count() << endl;}// boost::intrusive_ptrvoid testIntrusivePtr(){ //boost::intrusive_ptr
                                 
                                   intPtr(new ManagedObj[1], false); // error 要自己加入引用计数}// main functionint main(void){ // -----std::auto_ptr----- //testAutoPtr(); //testAutoPtr2(); //testAutoPtr3(); // -----boost::scoped_ptr----- //testScopedPtr(); // -----boost::shared_ptr----- //testSharedPtr1(); // -----boost::scoped_array----- //testScopedArray(); // -----boost::shared_array----- //testSharedArray1(); // -----boost::weak_ptr----- testWeakPtr(); return 0;}