实现一个简洁版的智能指针

Posted 2020-07-02

//智能指针可以自动销毁，用引用计数技术实现
#include<iostream>
using namespace std;

template<class T>
class SmartPtr
{
protected:
                 T* _ptr;
                 size_t* _cout;

                 void clear()
                {
                                 if(-- *_cout == 0)
                                {
                                                 delete _ptr;
                                                 delete _cout;
                                }
                }

public:
                SmartPtr( T* ptr = 0)
                                :_ptr( ptr)
                                ,_cout( new size_t (1))
                {}

                SmartPtr( const SmartPtr& p)
                                :_ptr( p._ptr)
                                ,_cout( p._cout)
                {
                                ++ *_cout;
                }

                 SmartPtr& operator=(const SmartPtr& p)
                {
                                ++ * p._cout;
                                clear();
                                _ptr = p._ptr;
                                _cout = p._cout;
                                
                                 return *this ;
                }

                ~SmartPtr()
                {
                                clear();
                }

                 T* operator->()
                {
                                 if(_ptr)
                                {
                                                 return _ptr;
                                }
                }

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

                 const T& operator*()const
                {
                                 if(_ptr)
                                {
                                                 return *_ptr;
                                }
                }
};