智能指針就是智能/自動化的管理指針所指向的動態資源的釋放
#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;
};
情況一：
情況二：
