共享智能指针shared_ptr的实现

#include<iostream>
#include<vld.h>
using namespace std;

//shared_ptr
//#define TEST
class sharend_base
{
public:
    sharend_base():use_count(1)
    {
#ifdef TEST
        cout << "Create sharend_base object." << endl;
#endif
    }
    virtual void dispose() = 0;//纯虚函数
    virtual void destroy()
    {
        delete this;
    }
    void release()
    {
        if (--use_count == 0)
        {
            dispose();
            destroy();
        }
    }
    void add_uc()
    {
        ++use_count;
    }
    ~sharend_base()
    {
#ifdef TEST
        cout << "Free sharend_base object." << endl;
#endif
    }
    long u_count()const
    {
        return use_count;
    }
private:
    long use_count;
};

template<typename Y>
class sharend_conunt_impl:public sharend_base
{
public:
    sharend_conunt_impl():pi(nullptr)
    {
#ifdef TEST
        cout << "Create sharend_conunt_impl object." << endl;
#endif
    }
    sharend_conunt_impl(Y*p):_pi(p)
    {
#ifdef TEST
        cout << "Create sharend_conunt_impl object." << endl;
#endif
    }
    sharend_conunt_impl(sharend_conunt_impl<Y>&p) :_pi(p._pi)
    {
#ifdef TEST
        cout << "Create sharend_conunt_impl object." << endl;
#endif
    }
    sharend_conunt_impl& operator=(sharend_conunt_impl&tm)
    {
        _pi = tm._pi;
    }
    ~sharend_conunt_impl()
    {
        _pi=nullptr;
#ifdef TEST
        cout << "Free sharend_conunt_impl object." << endl;
#endif
    }
    void destroy()
    {
        delete this;
    }
    void dispose()
    {
        delete _pi;
    }
private:
    Y*_pi;
};

class sharend_conunt
{
public:
    sharend_conunt():pe()
    {
#ifdef TEST
        cout << "Create shared_conunt object." << endl;
#endif
    }
    template <typename V>
    sharend_conunt(V*p):pe(new sharend_conunt_impl<V>(p))
    {
#ifdef TEST
        cout << "Create shared_conunt object." << endl;
#endif
    }
    sharend_conunt(sharend_conunt &p):pe(p.pe)
    {
        if (pe)
            pe->add_uc();
#ifdef TEST
        cout << "Create shared_conunt object." << endl;
#endif
    }
    ~sharend_conunt()
    {
        if (pe)
            pe->release();
#ifdef TEST
        cout << "Free shared_conunt object." << endl;
#endif
    }
    sharend_conunt& operator=(const sharend_conunt&tem)
    {
        if (this != &tem)
        {
            pe = tem.pe;
            if (pe)
                pe->add_uc();
        }
        return *this;
    }
    long count()const
    {
        return pe->u_count();
    }
private:
    sharend_base *pe; 
};

template<typename T>
class shared_ptr
{
public:
    shared_ptr():px(nullptr),pn()
    {
#ifdef TEST
        cout << "Create shared_ptr object." << endl;
#endif
    }
    shared_ptr(T*p):px(p),pn(p)
    {
        cout << "Create shared_ptr object." << endl;
    }
    shared_ptr(shared_ptr<T>& r):px(r.px),pn(r.pn)
    {
#ifdef TEST
        cout << "Create shared_ptr object." << endl;
#endif
    }
    ~shared_ptr()
    {
#ifdef TEST
        cout << "Free shared_ptr object." << endl;
#endif
    }
    void count()const
    {
        cout << "use_count="<< pn.count() << endl;
    }
    typedef shared_ptr<T> this_type;
    shared_ptr& operator=(const shared_ptr &tmp)
    {
        if (this != &tmp)
        {
            px = tmp.px;
            pn = tmp.pn;
        }
        return *this;
    }
    T & operator*()const
    {
        return *px;
    }
    T*operator->()const
    {
        return px;
    }
private:
    T*px;
    sharend_conunt pn;
};

主函数：

void main(){        int *ptr = new int(10);
    shared_ptr<int> ps(ptr);
    cout <<*ps<<endl;
    ps.count();
    {
        shared_ptr<int> pt = ps;
        ps.count();
    }
    ps.count();
    shared_ptr<int> pt;
    pt = ps;
    ps.count();}