shared_ptr.h

通用 linux 线程池, 使用 C++ 编写, 具有良好的扩展性.

#ifndef SHARED_PTR_H_
#define SHARED_PTR_H_

#ifndef NULL
#define NULL 0
#endif

namespace util
{
    template <class T>
    class shared_ptr;

    template <class T>
    class shared_data
    {
      private:
        friend class shared_ptr<T>;

        explicit shared_data(T *pT): _M_ptr(pT)
        {
            _M_nCount = 1;
        }

        ~shared_data()
        {
            delete _M_ptr;
        }

        void operator++()
        {
            ++_M_nCount;
        }

        void operator--()
        {
            --_M_nCount;
            if (_M_nCount == 0)
            {
                delete this;
            }
        }

        T &operator *()const
        {
            return  *_M_ptr;
        }

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

        bool operator == (T *pT)const
        {
            return _M_ptr == pT;
        }

        T *get()
        {
            return _M_ptr;
        }

        int use_count()
        {
            return _M_nCount;
        }

      private:
        T *_M_ptr;
        unsigned int _M_nCount;
    };

    template <class T>
    class shared_ptr
    {
        typedef shared_data<T> element;
      public:
        explicit shared_ptr(T *pT): _M_pD(NULL)
        {
            _M_pD = new element(pT);
        }
        explicit shared_ptr(): _M_pD(NULL)
		{
        }
        // copy constructor
        shared_ptr(const shared_ptr < T >  &rT)
        {
            _M_pD = rT.get_element();
            if (_M_pD != NULL)
            {
                ++(*_M_pD);
            }
        }

        ~shared_ptr()
        {
            if (_M_pD != NULL)
            {
                --(*_M_pD);
            }
        }

        // assignment operator
        shared_ptr < T >  &operator = (const shared_ptr < T >  &rT)
        {
            if (_M_pD != NULL)
            {
                --(*_M_pD);
            }
            _M_pD = rT.get_element();

            if (_M_pD != NULL)
            {
                ++(*_M_pD);
            }
            return  *this;
        }


        // assignment operator
        shared_ptr < T >  &operator = (shared_ptr < T >  &rT)
        {
            if (_M_pD != NULL)
            {
                --(*_M_pD);
            }
            _M_pD = rT.get_element();

            if (_M_pD != NULL)
            {
                ++(*_M_pD);
            }
            return  *this;
        }

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

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

		bool operator == (shared_ptr < T >  &rT)const
        {
            return rT.get_element() == _M_pD;
        }

        bool operator == (T *pT)const
        {
            if (_M_pD == NULL)
            {
                return pT == NULL;
            }
            return  *_M_pD == pT;
        }

        T *get()
        {
            if (_M_pD == NULL)
            {
                return NULL;
            }
            else
            {
                return _M_pD->get();
            }
        }

        void release()
        {
            if (_M_pD != NULL)
            {
                --(*_M_pD);
                _M_pD = NULL;
            }
        }

        void reset(T *pT)
        {
            if (_M_pD != NULL)
            {
                --(*_M_pD);
                _M_pD = NULL;
            }
            _M_pD = new element(pT);
        }

      private:
        element *get_element()const
        {
            return _M_pD;
        }

        element *_M_pD;
    };
}

#endif