智能指针就是智能/自动化的管理指针所指向的动态资源的释放

#include<iostream>

#include<cstdlib>

using namespace std;

//****************资源转移******************

//最好不要使用,会因为释放野指针造成程序奔溃

template<typename T>

class AutoPtr

{

public:

                AutoPtr( T* ptr )  

                                :_ptr( ptr)

                { }

                AutoPtr( AutoPtr<T >& ap)

                                :_ptr( ap._ptr)

                {

                                 ap._ptr = NULL ;

                }

                 AutoPtr<T >& operator=(const AutoPtr< T>& ap )

                {

                                 if (this != &ap)

                                {

                                                 if (_ptr != NULL )

                                                {

                                                                 delete _ptr;

                                                }

                                                _ptr = ap._ptr;

                                                 ap._ptr = NULL ;

                                }

                                 return *this ;

                }

                ~AutoPtr()

                {

                                 if (NULL != _ptr)

                                {

                                                 delete _ptr;

                                }

                }

private:

                 T* _ptr;

};


void FunTest()

{

                 int *p = new int[10];

                 delete[] p;

                 AutoPtr<int > ap1 = new int(10);

                 AutoPtr<int > ap2(ap1);    //把ap1这块空间交给ap2管理,不能通过ap1访问这块空间

                                          //函数结束的时候,释放ap1的时候,发现ap1成为野指针,程序崩溃

}


int main()

{


                system( "pause");

                 return 0;

}



//防拷贝

//将拷贝函数和赋值函数在类中声明为私有的,即使别人在外面可以定义,也不能调用

//若是声明为共有的,别人可以在类外定义并调用

template<typename T>

class ScoptArr

{

public:

                ScoptArr( T* ptr = NULL, size_t size = 0)

                                :_ptr( ptr)

                                , _size( size)

                { }

                 T& operator[] (size_t idx)

                {

                                 if (ide >= _size)

                                {

                                                 overflow_error err("数组访问越界" );

                                                                 throw err;

                                }

                                 return _ptr[idx ];

                }

                 const T & operator [](size_t idx) const;

                ~ScoptArr()

                {

                                 if (_ptr != NULL )

                                {

                                                 delete[] _ptr;

                                }

                }

private:

                ScoptArr(ScopedPtr< T> & ap);

                 ScoptArr<T > & operator =(const ScoptrArr &ap);

                 T* _ptr;

                 size_t  _size;

};





template<typename T>

class SharedPtr

{

public:

                SharedPtr( T* ptr = NULL)

                                :_ptr( ptr)

                                , _pCount( new int (0))

                {

                                 if (NULL != _ptr)

                                {

                                                *_pCount = 1;

                                }

                }

                SharedPtr( SharedPtr<T > & sp)

                                :_ptr( sp._ptr)

                                , _pCount( sp._pCount)

                {

                                (*_pCount)++;

                }

                 SharedPtr<T >& operator=(const SharedPtr< T>& sp )

                {

                                 if (this != &sp)

                                {

                                                 if (--(*_pCount) == 0&&(NULL !=_ptr)

                                                {

                                                                 delete _pCount;

                                                                 delete[] _ptr;

                                                }

                                                eles if (NULL == _ptr)

                                                {

                                                                 delete _pCount;

                                                }

                                                 else

                                                {

                                                                _ptr = sp._ptr;

                                                                _pCount = sp._pCount;

                                                                ++(*_pCount);

                                                }

                                }

                                 return *this ;

                }

                ~SharedPtr()

                {

                                 if (--(*_pCount) == 0)

                                {

                                                 delete[] _ptr;

                                                delelte _pCount;

                                }

                }

private:

                 T* _ptr;

                 int* _pCount;

};

情况一:

wKiom1cgfJfycOwcAAAfe4dC4FU119.png

情况二:

wKioL1cgfWLSEfjeAAAS1O3h__s406.png