boost.shared_ptr源码整理和使用说明

Source

#pragma once

 

//shared_ptr的简单实现版本

//基于引用记数的智能指针

//它可以和stl容器完美的配合

namespace kimi_boost

{

 

template<class T>

class shared_ptr

{

public:

    typedef T element_type;

    typedef T value_type;

    typedef T * pointer;

    typedef T& reference;

       typedef unsigned long size_type;

 

 

 

       explicit shared_ptr(T* p=0) : px(p)

       {

              try { pn = new size_type(1); }

              catch (...) { delete(p); throw; }

       }

       shared_ptr& operator= (T* p)

       {

              if(this->px == p) return *this;

              dispose();

              try { pn = new size_type(1); }

              catch (...) { delete(p); throw; }

              px=p;

              return *this;

       }

 

 

 

       shared_ptr(const shared_ptr& r) throw(): px(r.px)

       {

              ++*r.pn;

              pn = r.pn;

       }

       shared_ptr& operator= (const shared_ptr& r) throw()

       {

              if(this == &r) return *this;

              dispose();

              px = r.px;

              ++*r.pn;

              pn = r.pn;

              return *this;

       }

 

 

 

       template<typename Y> friend class shared_ptr;

       //为了让有继续关系的shared_ptr类型赋值或构造

       template<typename Y>

       shared_ptr(const shared_ptr<Y>& r)

       {

        px = r.px;

              ++*r.pn;

        pn = r.pn; // shared_count::op= doesn't throw

       }

       template<typename Y>

       shared_ptr& operator= (const shared_ptr<Y>& r)

       {

              dispose();

        px = r.px;

              ++*r.pn;

        pn = r.pn; // shared_count::op= doesn't throw

              return *this;

       }

 

 

 

       template<typename Y>

       shared_ptr(Y* py)

       {

              try { pn = new size_type(1); }

              catch (...) { delete(py); throw; }

              px=py;

       }

       template<typename Y>

       shared_ptr& operator= (Y* py)

       {

              if(this->px == py) return *this;

              dispose();

              try { pn = new size_type(1); }

              catch (...) { delete(py); throw; }

              px=py;

              return *this;

       }

 

 

       ~shared_ptr() { dispose(); }

 

 

 

 

 

 

 

 

       void reset(T* p=0)

       {

              if ( px == p ) return;

              if (--*pn == 0)

              { delete(px); }

              else

              { // allocate new reference

                     // counter

                     // fix: prevent leak if new throws

                     try { pn = new size_type; }

                     catch (...) {

                     // undo effect of —*pn above to

                     // meet effects guarantee

                     ++*pn;

                     delete(p);

                     throw;

                     } // catch

              } // allocate new reference counter

              *pn = 1;

              px = p;

       } // reset

 

 

       reference operator*() const throw(){ return *px; }

       pointer operator->() const throw(){ return px; }

       pointer get() const throw(){ return px; }

       size_type use_count() const throw()//

       { return *pn; }

       bool unique() const throw()//

       { return *pn == 1; }

 

private:

       void dispose() throw()

       {

              if (--*pn == 0)

                     { delete px; delete pn; }

       }

 

    T * px;    // contained pointer

    size_type* pn;  // reference counter

 

};  // shared_ptr

 

 

 

template<typename A,typename B>

inline bool operator==(shared_ptr<A> const & l, shared_ptr<B> const & r)

{

       return l.get() == r.get();

}

 

template<typename A,typename B>

inline bool operator!=(shared_ptr<A> const & l, shared_ptr<B> const & r)

{

       return l.get() != r.get();

}

 

}//namespace kimi_boost

Test code

class A

{

public:

       A(int _a=0):a(_a){}

       ~A(){}

protected:

       int a;

};

 

class B : public A

{

public:

       B(int _a=0):A(_a){}

       ~B(){}

};

 

void kimi_shared_ptr_test()

{

       using namespace std;

       using kimi_boost::shared_ptr;

 

       shared_ptr<int> sp;

       shared_ptr<int> sp2(new int(2));

       shared_ptr<int> sp3(sp2);

       shared_ptr<int> sp4;

       shared_ptr<int> sp5;

       sp=sp2;

       sp4=new int(3);

       sp.reset(new int(10000));

      

       vector< shared_ptr<int> > vsp;

       vsp.push_back(sp);

       vsp.push_back(sp2);

       vsp.push_back(sp3);

       vsp.push_back(sp4);

       vsp.push_back(sp5);

 

       shared_ptr<A> spa(new A(2));

       shared_ptr<B> spb(new B(3));

       spa = spb;

       shared_ptr<A> spa2(new B(2345));

 

       cout<<(sp2==sp3)<<endl;

       cout<<(spa==spb)<<endl;

}

Output

1

1