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