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”。