仔细想一下要做一个和boost里的share_ptr类似的带引用计数的智能指针也不是太难，今天下午花了点时间写了一个，支持多线程。

namespace XPtr {

     //引用计数模板对象，L 表示所使用的同步对象类型，用作引用计数增减时做同步操作

    template<typename L>

    class RefCounter {

    private:

        int counter;

        L _lock;

       //同步对象操作辅助类，构造函数中加锁，析构函数中解锁

        class LockHelper {

        private:

            L _l;

        public:

            LockHelper(L &l) {  _l = l;  _l.lock(); }

            ~LockHelper() { _l.unlock(); }

        };

    public:

        RefCounter():counter(0) {    }

        //整形转换操作符

        operator int() {   return counter;   }

        //

        int operator++() {

            LockHelper l(_lock);

            return ++counter;

        }

        //

        int operator--() {

            LockHelper l(_lock);

            return --counter;

        }

    };

    //单线程时的同步对象，全部为空，不做线程同步

    struct SingleThread {

        void lock() {};

        void unlock() {};

    };

     //主角登场，智能指针模板， T 为指针指向内容，ThreadLock为线程同步策略类，默认为单线程

    private:

        T * m_ptr;

        //引用计数类的指针，指向同一个指针的智能指针要共同维护一个引用计数类实例 

        RefCounter<ThreadLock> *m_pCounter;

    public:

       //智能指针可以不初始化，待以后赋值

        xptr():m_ptr(0),m_pCounter(0)         {}

        //用另一个typename P而不直接用T，这样可以支持用子类的指针类初始化父类智能指针

        //使用explicit关键字，表示禁止隐式类型转换，防止无意识的情况下把已有的原生指针转成智能指针

        template<typename P>

        explicit xptr(P *p)  {  create( new RefCounter<ThreadLock>(), p);    }

        //拷贝构造函数，若需要支持用子类的智能指针初始化，则需要另外申明一个模板拷贝构造函数，增加一个typename P，类似前面的构造函数

        //但由于需要改变引用计数，所以需要智能指针开放接口以取得引用计数对象和原始指针对象，这样会不太雅观，所以这里有个tradeoff  (见肥浩的留言)

        xptr(const xptr<T> &p) {   create(p.m_pCounter,p.m_ptr);    }

        //赋值操作，同上

        const xptr<T>& operator= (const xptr<T> &p) {

            if(&p != this) {

                destory();

                create(p.m_pCounter, p.m_ptr);

            }

            return *this ;

        }

        //析构函数，调用destory()辅助函数，用以减少引用计数，并适时销毁原始指针对象和引用计数对象

        ~xptr() { destory();}

        T* operator->() const{ return m_ptr;}

        //布尔值转换操作符，判断是否为空

        operator bool() {   return m_ptr!=0 ;   }

    private:

        //辅助函数，用以增加引用计数，取得原始指针对象和引用计数对象

        template<typename P>

        void create(RefCounter<ThreadLock> * pf , P* pp) {

            m_pCounter = pf;

            if(m_pCounter!=0)

                ++*m_pCounter;

            m_ptr = pp;

        }

        //辅助函数，用以减少引用计数，为零时销毁原始指针对象和引用计数对象

        void destory() {

           //在多线程环境下这里看似会有同步问题，但是那种情况是不会发生的，所以这样是安全的

            if(m_pCounter!=0 && --*m_pCounter==0) {

                delete m_pCounter;

                delete m_ptr;

            }

        }

    };

}

要用在多线程环境中的话需要根据平台实现一个同步类，内部有一个mutex，支持lock, unlock操作，使用时将此同步类作为智能指针的第二个模板参数即可。