ScopedPtr和SharedPtr

比眉伴天荒 2022-06-18 02:41 108阅读 0赞

除了使用移交管理权来解决多次释放同一块内存的方式外，我们还可以强制的不允许许程序进行拷贝构造和给赋值的操作

template <class T>
    class ScopedPtr
    {
    public :
            ScopedPtr( T * pStr = NULL)
                   :_pStr( pStr )
            {
    
            }
             T & operator*()
            {
                    return *_pStr;
            }
             T * operator->()
            {
                    return _pStr;
            }
            ~ScopedPtr()
            {
                    if (_pStr)
                   {
                            delete _pStr;
                           _pStr = NULL;
                           cout << "~AutoPtr()" << endl;
                   }
            }
    private :
             T * _pStr;
            ScopedPtr( ScopedPtr & ad);
             ScopedPtr <T >& operator=( ScopedPtr &ad);
    };
    void FunTest()
    {
             ScopedPtr <int > ap( new int);
            *ap = 10;
             //ScopedPtr<int>ap1(ap);
             //ScopedPtr<int>ap2;
             //ap2 = ap1;
    }

如果我们将//去掉，那么程序是不会通过编译的，因为我们显式的给出的拷贝构造函数和赋值运算符的重载是私有的，在类外我们是不能去访问类的私有成员的。这种方式能有效的规避多次释放同一块内存的问题

除此之外我们还可以通过引用计数的方式去解决这个问题，当然这个和在string类的引用计数原理是相似的，但是string类里面我们是多开辟4个字节的一段连续的存储空间而这里并不是。

template<class T>
    class SharedPtr
    {
    public:
        SharedPtr(T* pStr = NULL)
            :_pStr(pStr)
            ,_pCount(new int(1))
        {
    
        }
        SharedPtr(SharedPtr& sp)//拷贝构造函数
            :_pStr(sp._pStr)
            ,_pCount(sp._pCount)
        {
            ++(*_pCount);
        }
        SharedPtr<T>& operator=(SharedPtr& sp)//分三种情况
        {
            if (this != &sp&&_pStr != sp._pStr)//判断是不是自己给自己赋值这种方式更好
            {
                if (_pStr != NULL&&--(*_pCount) == 0)
                {
                    Release();
                }
                ++(*sp._pCount);
                _pStr = sp._pStr;
                _pCount = sp._pCount;
    
            }
            return *this;
        }
        int GetCount()
        {
            return *_pCount;
        }
        void Release()
        {
            delete _pStr;
            delete _pCount;
            _pStr = NULL;
            _pCount = NULL;
        }
        ~SharedPtr()
        {
            if ( --(*_pCount)== 0)
            {
                Release();
            }
        }
    private:
        int *_pCount;
        T* _pStr;
    };
    void FunTest()
    {
        SharedPtr<int> sp(new int);
        cout << sp.GetCount() << endl;
        SharedPtr<int> sp1(sp);
        cout << sp.GetCount() << endl;
        SharedPtr<int> sp2(sp);
        cout << sp.GetCount() << endl;
        SharedPtr<int> sp3(new int);
        sp = sp3;
        cout << sp.GetCount() << endl;
        cout << sp1.GetCount() << endl;
    }

通过引用计数我们能解决多次释放同一块内存空间的问题，并且和之间直接移交管理权的方式比较这种方式更加灵活安全。但是这种方式也只能处理new出来的空间因为new要和析构中的delete匹配。  
“\`