本文共 2362 字，大约阅读时间需要 7 分钟。

#include
     
      #include
      
       using namespace std;using namespace boost;int main(void){    int *p = new int(10);    shared_ptr
       
         ps(p);//    cout<<*ps<
        
         <
         
          <
          

关键在shared_ptr中存在共享引用计数。

3、框架的搭建

阅读源代码：

shared_ptr 中的私有数据成员：

private:    T *px;    shared_count pn; //对象成员，肯定先调这个对象的构造函数；

之前的引用计数通过一个指针，现在的引用计数通过一个对象，pn

构造函数的调用顺序：先虚基类，父类，对象成员，最后构造自己；

此时的模型如下：

其后调用对象成员的构造函数：

shared_counted中的私有数据成员：

private:    sp_counted_base *pi; //有一个指向引用计数器父类的指针；

此时就得先写：sp_counted_base类了；

sp_counted_base类中的私有数据成员：

private:    long use_count_;

然后看到在shared_counted的构造函数：

public:    template
     
        //此时类型不定，写模板函数        shared_count(T *p) : pi(new sp_counted_impl_xx(p)){ //特别重要，这个构造函数
     

此时就得写sp_counted_impl_xx类了：这是继承sp_counted_base类

其内部数据时成员：

private:    T *px_;

此时整体的建构体系就已经形成：

我认为是这样的：

  (1)、先实现了shared_ptr类，因为有对象成员，其后调用构造函数，

  (2)、实现了shared_count; 其数据成员有sp_counted_base,

  (3)、因为编译器的顺序，先类名，在数据成员，最后函数，所以此时先实现sp_counted_base;

  (4)、因为shared_counted中的构造函数要在堆上开辟sp_counted_impl_xx空间，最后实现是sp_counted_impl_xx，它有继承sp_counted_base,所以构造函数的调用顺序就很清楚了。

  构造函数的调用顺序：sp_counted_base、sp_counted_impl_xx、shared_count、shared_ptr

此时的具体实现代码如下：

#ifndef _CONFIG_H_#define _CONFIG_H_#include
     
      using namespace std;#endif#ifndef _SHARED_PTR_H_#define _SHARED_PTR_H_#include"shared_count.h"template
      
       class shared_ptr{public:    shared_ptr(T *p = 0) : px(p), pn(p){        cout<<"Create shared_ptr object!"<
       
        <<"Free shared_ptr object"<
        
           //此时类型不定，写模板函数        shared_count(T *p) : pi(new sp_counted_impl_xx
         
          (p)){        cout<<"Create shared_cout object!"<
          
           <<"Free shared_count object"<
           
            class sp_counted_impl_xx : public sp_counted_base{public:    sp_counted_impl_xx(T *p) : px_(p){        cout<<"Create sp_counted_impl_xx object"<
            
             <<"Free sp_counted_impl_xx object"<
             
              #include"shared_ptr.h"using namespace std;int main(void){    int *p = new int(10);    shared_ptr
              
                ps(p);   }
              
             
            
           
          
         
        
       
      
     

以下是运行结果：

以上就是只搭好了大致的框架，并没有考虑内存泄漏，析构的具体写法和其它函数的实现；

那么整个模型如下：