boost中的智能指针shared_ptr的指针管理

最近在阅读《Beyond the C++ STL》一书的shared_ptr一章时，遇到点困惑，记录如下：

原书44~45页

#include "boost/shared_ptr.hpp" 
#include <vector> 
#include <iostream> 
 
class A { 
public: 
  virtual void sing()= 
protected: 
  virtual ~A() {}; 
}; 
 
class B : public A { 
public: 
  virtual void sing() { 
    std::cout << "Do re mi fa so la"; 
  } 
}; 
 
boost::shared_ptr<A> createA() { 
  boost::shared_ptr<A> p(new B()); 
  return p; 
} 
 
int main() { 
  typedef std::vector<boost::shared_ptr<A> > container_type; 
  typedef container_type::iterator iterator; 
 
  container_type container; 
  for (int i=0;i<10;++i) { 
    container.push_back(createA()); 
  } 
  
  std::cout << "The choir is gathered: \n"; 
  iterator end= 
  for (iterator it=container.begin();it!=end;++it) { 
    (*it)->sing(); 
  } 
} 

上面的例子示范了一个强有力的技术，它涉及 A里面的 protected 析构函数。因为函数  createA 返回的是  shared_ptr<A>, 因此不可能对 shared_ptr::get返回的指针调用  delete 。这意味着如果为了向某个需要裸指针的函数传送裸指针而从 shared_ptr中取出裸指针的话，它不会由于意外地被删除而导致灾难。那么，又是如何允许  shared_ptr 删除它的对象的呢？ 这是因为指针指向的真正类型是  B;而 B的析构函数不是protected 的。这是非常有用的方法，用于给shared_ptr中的对象增加额外的安全性。 

这句话没有看懂，什么叫“指向的真正类型是B”呢？shared_ptr中不是 T *p么？这明明是指向的A啊，为什么说是指向的B呢？

因为A的析构函数为 protected 的，所以 shared_ptr 类必然不能在其析构函数里调用delete来删除它保存的对象。那么 shared_ptr 究竟是怎么删除它的对象的呢？

好奇心驱使我读了boost关于shared_ptr的源码。从头到尾读了一遍后，竟然没有发现 shared_ptr 的析构函数！因此必然不是在 shared_ptr 的析构函数里删除它的对象。那究竟在哪里呢？

下面是我截取的 shared_ptr 类的实现源码，从中可以窥见一斑：

template<class T> class shared_ptr
{
private:

    // Borland 5.5.1 specific workaround
    typedef shared_ptr<T> this_type;

public:
    ......

    typedef typename boost::detail::sp_element< T >::type element_type;

    ......

public:
    ......

    template<class Y>
    explicit shared_ptr( Y * p ): px( p ), pn() // Y must be complete
    {
        boost::detail::sp_pointer_construct( this, p, pn );
    }

    ......

private:
    element_type * px;                 // contained pointer
    boost::detail::shared_count pn;    // reference counter

};  // shared_ptr

可以看到，在 shared_ptr 的构造函数，首先将Y *p 赋值给了类成员变量 T* px，然后调用了函数boost::detail::sp_pointer_construct()

template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T > * ppx, Y * p, boost::detail::shared_count & pn )
{
    boost::detail::shared_count( p ).swap( pn );
    
    ......
}

boost::detail::sp_pointer_construct()中调用了shared_count()类，该类是用于管理引用计数的，它的构造函数中的参数 是 Y *p

class shared_count
{
private:

    sp_counted_base * pi_;

    ......

    template<class Y> explicit shared_count( Y * p ): pi_( 0 )
    {
        try
        {
            pi_ = new sp_counted_impl_p<Y>( p );
        }
        catch(...)
        {
            boost::checked_delete( p );
            throw;
        }
    }

    ~shared_count() // nothrow
    {
        if( pi_ != 0 ) pi_->release();
    }

    ......

};

可以看到，在shared_count的构造函数中，使用 Y *p 构造了一个 sp_counted_impl_p 类，在该类的构造函数中，仅仅是将 指针 Y *p  赋值给了成员变量 px_

class sp_counted_base
{
    ......

public:

    ......

    void release() // nothrow
    {
        pthread_mutex_lock( &m_ );
        long new_use_count = --use_count_;
        pthread_mutex_unlock( &m_ );

        if( new_use_count == 0 )
        {
            dispose();

            ......

        }
    }

    virtual void dispose() = 0; // nothrow

    ......
};


template<class X> class sp_counted_impl_p: public sp_counted_base
{
private:

    X * px_;
    
    ......

    explicit sp_counted_impl_p( X * px ): px_( px )
    {
    }

    virtual void dispose() // nothrow
    {
        ......

        boost::checked_delete( px_ );

	......
    }

    ......
};

因此，从上面的代码，我们可以很清楚的知道，类 shared_ptr 中 使用 成员变量 boost::detail::shared_count pn 的 成员变量 sp_counted_base * pi_ 的 成员变量  X * px_ 保存了 类型为 Y 的变量 *p，而类 shared_ptr 的成员变量 element_type * px 仅仅指向了 类型为 Y 的变量 *p。


于是，在 类 shared_ptr 析构时，它调用 类 sp_counted_base 的 release()函数，调用了 类sp_counted_impl_p 的dispose()函数的实现，并最终调用到了 boost::checked_delete( px_ )，而我们知道px_的类型是 Y，这也就是为什么 《Beyond the C++ STL》中说 shared_ptr中 “这是因为指针指向的真正类型是  B”。