智能指针（一）

动态内存与智能指针

在C++中，动态内存的管理是通过一对运算符来完成的。new在动态内存中为对象 分配空间并且返回一个指向该类对象的指针。delete接受一个动态对象的指针，销毁该对象，并释放与之关联的内存。
动态内存的使用很容易出现问题，因为确保正确的时间释放内存是极其困难的。有时我们会忘记释放内存，导致内存泄漏。
为了更容易（或者说是为了安全）地使用动态内存，我们提出了智能指针。（个人人觉得智能指针特别方便，它把内存管理封装在一个类里面，而类自己就可以完成对象的销毁，省得自己去操心）

为什么使用智能指针

直接看代码，一目了然

void Test2()
{
int* p1 = new int(2);
bool isEnd = true;

//...
if (isEnd)
{
//delete p1;//这里要小心
return;
}
//...

delete p1;
}
/////////////////////////////////////////////////
void DoSomeThing()
{
//...
throw 2;
//...
}

void Test2()
{
int* p1 = new int(2);

//...
try {
DoSomeThing();
}
catch (...)
{
//delete p1;//抛出异常要在这里delete否则出现野指针
throw;
}
//...

delete p1;
}

引入智能指针

定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。

1.auto_ptr，这个其实是一个坑货

看代码：

template<class T>
class AutoPtr
{
public:
AutoPtr( T* ptr)
:_ptr(ptr)
{}
AutoPtr(AutoPtr<T>& s) //里面不能用const
:_ptr(s._ptr)
{
s._ptr = NULL;
}

AutoPtr& operator=(AutoPtr<T>& s)
{
if (s._ptr != _ptr)
{
delete _ptr;
_ptr = s._ptr;
s._ptr = NULL;
}
return *this;
}

~AutoPtr()
{
if (_ptr)
delete _ptr;
}

T& operator*()
{
return *_ptr;
}
private:
T* _ptr;
};

//存在问题

AutoPtr<int> ap1 = new int(1);
AutoPtr<int> ap2(ap1);
AutoPtr<int> ap3(ap2);
*ap1 = 10;//直接崩溃了

虽然上面的auto_ptr解决了内存管理问题，你不用在担心什么时候去释放那个空间。但是在拷贝构造和运算符重载时，我们很尴尬。每拷贝一个对象就要释放前面的那个对象，那么我们在后面想访问前面定义那个对象岂不是会出现问题。本来是为了解决内存问题，现在又在拷贝构造出现问题。

2.scoped_ptr 防拷贝简单暴力

对比上面的auto_ptr，会出现拷贝问题，我们把拷贝构造和赋值运算符声明为private这样外面的东西就不能访问这个成员函数了。这样就是简单暴力的求解方法

private:
ScopePtr(const ScopePtr& sp);

ScopePtr<T>& operator=(const ScopePtr& sp);

3.为了解决上面问题，引入shared_ptr，在这个类里面引用引用计数，和string一样，计数拷贝次数，当拷贝计数只有一次的话，就可以析构这个东西了。

template <class T>
class SharePtr
{
public:
SharePtr( T* ptr)
:_ptr(ptr)
, _pCount(new int(1))
{}

~SharePtr()
{
if (--(*_pCount) == 0)
{
delete _pCount;
delete _ptr;
}
}

SharePtr(SharePtr<T>& s)
:_ptr(s._ptr)
, _pCount(s._pCount)
{
++*_pCount;
}

SharePtr<T>& operator=(SharePtr<T>& s)
{
if (this != &s)
{
if ( --(*_pCount) == 0 )//这里解决了一个问题，在下面说
{
delete _ptr;
delete _pCount;
}

_ptr = s._ptr;
_pCount = s._pCount;
++(*_pCount);

}
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
int *_pCount;
T    *_ptr;
};

用test来测试上面代码
void Test()
{
SharePtr<int> s1 = new int(10);
SharePtr<int> s2(s1);

SharePtr<int> s3 = new int(20);
s2 = s3;//这块很容易出问题
}

对上面问题的解释：



所以上面那个拷贝构造的时候，解决了这个问题。