C++ 智能指针详解

这篇博客主要参考上面这个博客和 《Boost 程序库完全开发指南：深入 C++ 准标准库 》 第三版 

一个智能指针就是一个C++的对象，这个对象的行为像一个指针，但是它却可以在其不需要的时候自动删除。注意这个“其不需要的时候”， 这可不是一个精确的定义。这个不需要的时候可以指好多方面：局部变量退出函数作用域、类的对象被析构……。

示例代码：

#include <iostream>
#include <memory>
using namespace std;


class A
{
public:
    A(){ cout<<"A constructor"<<endl; }
    ~A(){ cout<<"A destructor"<<endl;}
    void dis(){ cout<<"Are you MI fans"<<endl; }
private:
    int data;
};

//自定义智能指针
class SPA
{
public:
    SPA(A* p)
        :_p(p)
    {
        cout<<"SPA"<<endl;
    }
    ~SPA()
    {
        cout<<"~SPA"<<endl;
        delete _p;
    }
    A* operator ->() //重载 -> 运算符，返回值是一个指针
    {
        return _p;
    }
    A& operator *() //重载 解引用 * 运算符，
    {
        return *_p;
    }
private:
    A * _p;
};

void foo()
{
    
    SPA a(new A); //自定义的智能指针，因为没有使用模板，所以只能指向A的对象
    cout<<"---------------------------------"<<endl;
    SPA b((A*)23);
    a->dis();   // (a.operator ->())->dis();
    (*a).dis(); //(a.operator *()).dis();;
    
    //“auto_ptr”是系统提供的智能指针，使用模本，通用编程
    auto_ptr<A> p(new A);
    p->dis();
}

int main()
{
    foo();
    return 0;
}

使用模版实现代码：

#include<iostream>
using namespace std;


template<typename T>
class My_Smart_Ptr
{
public:
    My_Smart_Ptr(T *data)
    {
        if(NULL == data) this->data = NULL;
        else this->data = data;
    }
    ~My_Smart_Ptr()
    {
        if(NULL != this->data) delete this->data;
        this->data = NULL;
    }

    T& operator *() const
    {
        return *(this->data);
    }
    T* operator &() const
    {
        return this->data;
    }


private:
    T *data;
};


int main()
{   
    int *pInt = new int(10);
    cout<<*pInt<<endl;

    My_Smart_Ptr<int> mp1(pInt);
    cout<<*mp1<<endl;

    *mp1 = 20;
    cout<<*mp1<<endl;
    cout<<*pInt<<endl;

    My_Smart_Ptr<int> mp2(new int);
    *mp2 = 30;
    cout<< *mp2 <<endl;

    cout<<"pInt: "<<pInt<<endl; // 输出16进地址

    // mp1 是一个对象，使用取地址符，调用的是 operator &() const 这个重载函数，输出的地址和 pInt 地址一样
    cout<<"&mp1: "<<&mp1<<endl;

    return 0;
}

运行截图：

boost定义了多个不同的智能指针来管理不同的场景。

一、简介

由于 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）。

二、具体使用

对于编译器来说，智能指针实际上是一个栈对象，并非指针类型，在栈对象生命期即将结束时，智能指针通过析构函数释放有它管理的堆内存。所有智能指针都重载了“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;   
};

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 智能指针可以解决如上问题。
让我们继续向下看。
*/

boost::scoped_ptr

scoped_ptr

boost::scoped_ptr是一个简单的智能指针，它能够保证在离开作用域后对象被自动释放。
boost::scoped_ptr的实现是利用了一个栈上的对象去管理一个堆上的对象，从而使得堆上的对象随着栈上的对象销毁时自动删除。
boost::scoped_ptr 特点

• 不能转换所有权
  scoped_ptr所管理的对象生命周期仅仅局限于一个区间（该指针所在的"{}"之间），无法传到区间之外，这就意味着scoped_ptr对象是不能作为函数的返回值的。
• 不能共享所有权
  这个特点一方面使得该指针简单易用。另一方面也造成了功能的薄弱：不能用于STL的容器中。(用shared_ptr代替)
• 不能用于管理数组对象
  由于scoped_ptr是通过delete来删除所管理对象的，而数组对象必须通过deletep[]来删除，因此scoped_ptr是不能管理数组对象的，如果要管理数组对象需要使用boost::scoped_array类。scoped_ptr 不能指向一块能够动态增长的内存区域(用scoped_array代替)

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。
*/

boost::shared_ptr

shared_ptr

share_ptr 高级议题（参看）Boost 程序库完全开发指南：深入 C++ 准标准库 》

boost::scoped_ptr虽然简单易用，但它不能共享所有权的特性却大大限制了其使用范围，shared_ptr可以解决这一局限。在标准C++中为 std::shared_ptr ，在Boost C++库里，这个智能指针命名为boost::shared_ptr。
shared_ptr的管理机制其实并不复杂，就是对所管理的对象进行了引用计数，当新增一个shared_ptr对该对象进行管理时，就将该对象的引用计数加一；减少一个shared_ptr对该对象进行管理时，就将该对象的引用计数减一，如果该对象的引用计数为0的时候，说明没有任何指针对其管理，才调用delete释放其所占的内存。

boost::shared_ptr 特点

• 可以共享对象的所有权
  和scoped_ptr相比shared_ptr可以共享对象的所有权，所以保存在容器中的拷贝（包括容器在需要时额外创建的拷贝）都是和原件相同的，可以在标准容器中安全的使用动态分配的对象。
• 线程安全的
  shared_ptr 对象提供与内建类型一样的线程安全级别。一个 shared_ptr 实例可以同时被多个线程“读”（仅使用不变操作进行访问）。 不同的 shared_ptr 实例可以同时被多个线程“写入”（使用类似 operator= 或 reset 这样的可变操作进行访问）（即使这些实例是拷贝，而且共享下层的引用计数）。 任何其它的同时访问的结果会导致未定义行为。”

• 同一个shared_ptr被多个线程“读”是安全的。
• 同一个shared_ptr被多个线程“写”是不安全的。
• 共享引用计数的不同的shared_ptr被多个线程”写“是安全的。

• 支持自定义的deleter
• 不能指向一块动态增长的内存(用share_array代替)

boost::shared_ptr 注意事项

• shared_ptr可以当做函数的参数，也可以当做函数的返回值，这时候相当于使用复制构造
• shared_ptr可以被用于标准容器，复制时相当于使用复制构造
• 要注意不要循环引用，那样会造成对象不会被释放

使用boost::shared_ptr的一大陷阱就是用一个raw pointer多次创建boost::shared_ptr，这将导致该raw pointer被多次销毁当boost::shared_ptr析构时。即不能如下使用：

int *a = new int(5);
boost::shared_ptr ptr1(a);
boost::shared_ptr ptr2(a);　　//错误！ 

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 是再好不过的了。
  
在此，我们已经看完单个对象的智能指针管理，关于智能指针管理数组，我们接下来讲到。
*/

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 了，一个用引用计数解决复制、参数传递的智能指针类。
*/

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 种。
可如下还有两种智能指针，它们肯定有用，但有什么用处呢，一起看看吧。
*/

boost::weak_ptr

weak_ptr

weak_ptr 就是一个弱指针。weak_ptr 被shared_ptr控制， 它可以通过share_ptr的构造函数或者lock成员函数转化为share_ptr。

weak_ptr的一个最大特点就是它共享一个share_ptr的内存，但是无论是构造还是析构一个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 的引用计数，用以降低复杂度，更好的管理对象。
*/

shared_ptr引用计数是一种便利的内存管理机制，但它有一个很大的缺点，那就是不能管理循环引用的对象。例如：

#include <string>  
#include <iostream>  
#include <boost/shared_ptr.hpp>  
#include <boost/weak_ptr.hpp>  

class parent;  
class children;  

typedef boost::shared_ptr<parent> parent_ptr;  
typedef boost::shared_ptr<children> children_ptr;  

class parent  
{  
public:  
    ~parent() { std::cout <<"destroying parent\n"; }  
    
public:  
    children_ptr children;  
};  

class children  
{  
public:  
    ~children() { std::cout <<"destroying children\n"; }  
    
public:  
    parent_ptr parent;  
};  

void test()  
{  
    parent_ptr father(new parent());  
    children_ptr son(new children);  
    
    father->children = son;  
    son->parent = father;  
}  

void main()  
{  
    std::cout<<"begin test...\n";  
    test();  
    std::cout<<"end test.\n";  
}

运行该程序可以看到，即使退出了test函数后，由于parent和children对象互相引用，它们的引用计数都是1，不能自动释放，并且此时这两个对象再无法访问到,这就引起了内存泄漏。
一般来讲，解除这种循环引用有下面有三种可行的方法：

• 当只剩下最后一个引用的时候需要手动打破循环引用释放对象。
• 当parent的生存期超过children的生存期的时候，children改为使用一个普通指针指向parent。
• 使用弱引用的智能指针打破这种循环引用。在父对子引用时使用强引用，子对父引用时使用弱引用，从而避免了循环引用。

虽然这三种方法都可行，但方法1和方法2都需要程序员手动控制，麻烦且容易出错。这里主要介绍一下第三种方法和boost中的弱引用的智能指针boost::weak_ptr。

强引用
一个强引用当被引用的对象活着的话，这个引用也存在（就是说，当至少有一个强引用，那么这个对象就不能被释放）。boost::share_ptr就是强引用。

弱引用
它仅仅是对象存在时候的引用，当对象不存在时弱引用能够检测到，从而避免非法访问，弱引用也不会修改对象的引用计数。这意味这弱引用它并不对对象的内存进行管理，在功能上类似于普通指针，然而一个比较大的区别是，弱引用能检测到所管理的对象是否已经被释放，从而避免访问非法内存。

在C++中，普通指针可看做弱引用，智能指针可看做强引用，尽管指针不能算"真正"的弱引用，因为弱引用应该能知道何时对象变成不可访问的了。

打破循环引用
在父对子引用时使用强引用，子对父引用时使用弱引用，从而避免了循环引用。

//详细例子见 Boost智能指针-weak_ptr  
class children  
{  
public:  
    ~children() { std::cout <<"destroying children\n"; }  
    
public:  
    boost::weak_ptr<parent> parent;  
};

虽然通过弱引用指针可以有效的解除循环引用，但这种方式必须在程序员能预见会出现循环引用的情况下才能使用，也可以是说这个仅仅是一种编译期的解决方案，如果程序在运行过程中出现了循环引用，还是会造成内存泄漏的。

boost::intrusive_ptr

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

讲完如上 6 种智能指针后，对于一般程序来说 C++ 堆内存管理就够用了，现在有多了一种 boost::intrusive_ptr，这是一种插入式的智能指针，内部不含有引用计数，需要程序员自己加入引用计数，不然编译不过（⊙﹏⊙b汗）。

intrusive_ptr

在多数情况下，我们不使用 boost::intrusive_ptr, 因为共享所有权的功能已在 boost::shared_ptr中提供，而且非插入式智能指针比插入式智能指针更灵活。
但是，有时候也会需要插入式的引用计数，可能是由于旧的代码，或者是为了与第三方的类进行集成。当有这种需要时，可以用 intrusive_ptr ，它具有与其它Boost智能指针相同的语义。如果你使用过其它的Boost智能指针，你就会发现不论是否插入式的，所有智能指针都有一致的接口。
使用intrusive_ptr的类必须可以提供引用计数。intrusive_ptr 通过调用两个函数，intrusive_ptr_add_ref 和 intrusive_ptr_release来管理引用计数；这两个函数必须正确地操作插入式的引用计数，以保证 intrusive_ptr正确工作。在使用intrusive_ptr的类中已经内置有引用计数的情况下，实现对intrusive_ptr的支持就是实现这两个函数。有些情况下，可以创建这两个函数的参数化版本，然后对所有带插入式引用计数的类型使用相同的实现。多数时候，声明这两个函数的最好的地方就是它们所支持的类型所在的名字空间。 在以下情况时使用 intrusive_ptr

• 需要把 this 当作智能指针来使用。
• 已有代码使用或提供了插入式的引用计数。
• 智能指针的大小必须与裸指针的大小相等。

对比boost::shared_ptr

使用boost::shared_ptr用户类本省不需要具有引用计数功能，而是由boost::shared_ptr来提供；使用boost::shared_ptr的一大陷阱就是用一个raw pointer多次创建boost::shared_ptr，这将导致该raw pointer被多次销毁当boost::shared_ptr析构时。即不能如下使用：

int *a = new int(5);
boost::shared_ptr ptr1(a);
boost::shared_ptr ptr2(a);　　//错误！ 

boost::intrusive_ptr完全具备boost::shared_ptr的功能，且不存在shared_ptr的问题，即可以利用raw pointer创建多个intrusive _ptr，其原因就在于引用计数的ref_count对象，shared_ptr是放在shared_ptr结构里，而目标对象T通过继承intrusive_ptr_base将引用计数作为T对象的内部成员变量，就不会出现同一个对象有两个引用计数器情况。

那么为什么通常鼓励大家使用shared_ptr，而不是intrusive_ptr呢， 在于shared_ptr不是侵入性的，可以指向任意类型的对象； 而intrusive_ptr所要指向的对象，需要继承intrusive_ptr_base，即使不需要，引用计数成员也会被创建。

shared_ptr比普通指针提供了更完善的功能。有一个小小的代价，那就是一个共享指针比普通指针占用更多的空间，每一个对象都有一个共享指针，这个指针有引用计数器以便于释放。但对于大多数实际情况，这些都是可以忽略不计的。

intrusive_ptr 提供了一个折中的解决方案。它提供了一个轻量级的引用计数器，但必须对象本身已经有了一个对象引用计数器。这并不是坏的想法，当你自己的设计的类中实现智能指针相同的工作，那么一定已经定义了一个引用计数器，这样只需要更少的内存，而且可以提高执行性能。

如果你要使用intrusive_ptr 指向类型T，那么你就需要定义两个函数：intrusive_ptr_add_ref 和intrusive_ptr_release。下面是一个简单的例子解释如何在自己的类中实现：

#include "boost/intrusive_ptr.hpp"

// forward declarations(前向声明)
class CRefCounted;

namespace boost
{
    void intrusive_ptr_add_ref(CRefCounted * p);
    void intrusive_ptr_release(CRefCounted * p);
}

// My Class
class CRefCounted     
{   
private:
    long    references;
    friend void ::boost::intrusive_ptr_add_ref(CRefCounted * p);
    friend void ::boost::intrusive_ptr_release(CRefCounted * p);
public:
    CRefCounted() : references(0) {}  // initialize references to 0
};

// class specific addref/release implementation
// the two function overloads must be in the boost namespace on most compilers:
namespace boost
{
    inline void intrusive_ptr_add_ref(CRefCounted * p)
    {
        // increment reference count of object *p   
        ++(p->references);
    }
    
    inline void intrusive_ptr_release(CRefCounted * p)
    { 
        // decrement reference count, and delete object when reference count reaches 0
        if (--(p->references) == 0)  
            delete p; 
    }
} // namespace boost

/*
这是一个最简单的（非线程安全）实现操作。
但作为一种通用的操作，如果提供一种基类来完成这种操作或许很有使用价值，也许在其他地方会介绍到。
*/

总结

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

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 函数），因为可以用智能指针去管理。

    下面是几个使用智能指针需要注意的地方：

1. 声明一个智能指针的时候要立即给它实例化， 而且一定不能手动释放它。
2. …_ptr<T> 不是T* 类型。所以：

                a: 声明的时候要…_ptr<T> 而不是….._ptr<T*>

                b：不能把T* 型的指针赋值给它

                c: 不能写ptr=NULl, 而用ptr.reset()代替。

1. 不能循环引用。
2. 不要声明临时的share_ptr， 然后把这个指针传递给一个函数

---------------------------------------

[1]参见《effective C++（3rd）》，条款06 。

[2]关于 boost 库的使用，可本博客另外一篇文章：《在 Windows 中编译 boost1.42.0》。

[3]读者应该看到了，在我所有的名字前，都加了命名空间标识符std::（或boost::），这不是我不想写 using namespace XXX 之类的语句，在大型项目中，有可能会用到 N 个第三方库，如果把命名空间全放出来，命名污染（Naming conflicts）问题很难避免，到时要改回来是极端麻烦的事情。当然，如果你只是写 Demo，可以例外。