什么是智能指针
智能指针(smart pointer)的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象的指针指向同一对象。
提到智能指针就会想到RAII，但是要明白，智能指针并不等同于RAII，智能指针只是RAII的一种应用。而RAII则是一种规范。
是一种用来解决问题的思想，定义类来封装资源并进行分配和释放，构造函数完成资源的分配和初始化，析构函数完成资源的清理 智能指针不是指针，是一个类，可以实现：智能管理指针的释放，能够想一个指针一样使用，完成正常的复制拷贝。
早期的智能指针是auto_ptr，下面来模拟实现它。
template <class T>
class AutoPtr
{
public:
T * _ptr;
public:
AutoPtr(T* ptr)//构造函数
:_ptr(ptr)
{
cout<<"构造函数"<<endl;
}
AutoPtr(AutoPtr<T>&ap)//拷贝构造函数
:_ptr(ap._ptr)
{
cout<<"拷贝构造函数"<<endl;
ap._ptr = NULL;
}
~AutoPtr()//析构函数
{
cout<<"析构函数"<<endl;
delete[]_ptr;
}
AutoPtr<T> & operator = (AutoPtr<T>&ap)//赋值运算符的重载
{
if(this!=&ap)
{
delete _ptr;//赋值前先释放它
_ptr = ap._ptr;
ap._ptr = NULL;//转移管理权
}
cout<<"赋值运算符的重载"<<endl;
return *this;
}
T &operator *()//*的重载
{
return *_ptr;
}
T *operator ->()//->的重载
{
return _ptr;
}
};
void test()
{
AutoPtr<int> p1(new int (4));
AutoPtr<int> p2(new int);
p2 = p1;
}
int main ()
{
test();
return 0;
}
但是这个智能指针的设计是失败的，他是存在缺陷的。因为会有管理权的转移。也就是说只要我一赋值，或者拷贝构造就会出现管理权转移的情况。
所以我们又有了另一种智能指针，scoped_ptr，他的实现原理就是简单粗暴的，既然你会有拷贝和赋值的问题，那我就不让怒拷贝，也不让你赋值。下面我们来模拟实现一下它。
模拟实现scoped_ptr
template <class T>
class ScopedPtr
{
protected:
T * _ptr;
public:
ScopedPtr(T *ptr)//构造函数
:_ptr(ptr)
{
cout<<"构造函数"<<endl;
}
~ScopedPtr()//析构函数
{
cout<<"析构函数"<<endl;
delete[]_ptr;
}
T &operator *()//*的重载
{
return *_ptr;
}
T *operator ->()//->的重载
{
return _ptr;
}
private:
ScopedPtr(const ScopedPtr<T>&sp);//只声明，不定义
ScopedPtr<T> &operator = (const ScopedPtr<T>&);
};
struct A
{
int _a;
int _b;
};
void test()
{
ScopedPtr<int> sp1(new int(4));
//ScopedPtr<int> sp2(p1);//在这里是无法调用拷贝构造函数的，因为他并没有定义，而且还是一个私有的函数，这样又可以保证即使在类外也不会被修改。
ScopedPtr<A> sp2(new A);
sp2->_a = 10;
sp2->_b = 20;
}
int main()
{
test();
return 0;
}
显然scoped_ptr虽然解决了管理权转移的问题，但是，在实际应用中难免会用到拷贝构造函数，和赋值运算符的重载。所以，为了解决这个问题，我们又出现了一个更加强大的智能指针，shared_ptr.
shared_ptr 是用了共享引用计数的原理，它支持赋值运算符的重载，拷贝构造。下面我们来模拟实现一下它。
模拟实现shared_ptr
template<class T>//实现仿函数
struct Delete//删除的是new出来的对象
{
void operator ()(T* ptr)
{
delete ptr;
}
};
template<class T>//实现仿函数
struct DeleteArray//删除数组
{
void operator ()(T* ptr)
{
delete [] ptr;
}
};
template<class T,class D = Delete<T>>//传一个缺省的参数
class SharedPtr
{
protected:
T * _ptr;
int * _countRef;
D _del;//定制一个删除器
public:
SharedPtr(T * ptr)//构造函数
:_ptr(ptr)
,_countRef(new int (1))
{
cout<<"构造函数"<<endl;
}
SharedPtr<T,D>(const SharedPtr<T,D>&sp)//拷贝构造函数
:_ptr(sp._ptr)
,_countRef(sp._countRef)
{
cout<<"拷贝构造函数"<<endl;
++(*_countRef);//既然调用了拷贝构造函数，肯定是拷贝构造了一个对象，所以直接引用计数加1
}
~SharedPtr()//析构函数
{
cout<<"析构函数"<<endl;
Release();
}
SharedPtr<T,D>&operator = (SharedPtr<T,D> & sp)
{
if (_ptr != sp._ptr)//判断是否自己给自己赋值或者是指向同一块空间里的对象见得赋值。
{
Release();
_ptr = sp._ptr;
_countRef = sp._countRef;
++(*_countRef);//进行了赋值后就指向了这个对象，所以当前对象的引用计数加1
}
return *this;
}
T &operator *()
{
return *_ptr
}
T *operator ->()
{
return _ptr;
}
private:
void Release()
{
if(--(_countRef)==0)//当引用计数的值为0时就说明已经没有对象在用这个空间了，就可以释放掉了。
{
cout<<_ptr<<endl;//这里主要是为了看一下是否调到了这个函数，，把它的地址打印一下。
_del(_ptr);//这里就用到了定制的删除器
delete _countRef;
}
}
};
void test()
{
SharedPtr<int> sp1(new int(2) );
//这里构造了一个对象会调用一次构造函数
SharedPtr<int> sp2(sp1);
//sp2对象是用sp1对象拷贝构造出来的所以这里调用了一次拷贝构造函数
SharedPtr<int> sp3(new int(4));
SharedPtr<int> sp4(new int(5));
sp1 = sp4;
sp2 = sp3;
SharedPtr<string> sp5(new string);
SharedPtr<string,DeleteArray<string>> sp6(new string[10]); //这个主要是为了看是否解决了深浅拷贝的问题。因为string类有深浅拷贝的情况
}
int main()
{
test();
return 0;
}从上面带代码中我们可以看到，这个职能制针可以实现拷贝构造，复制运算符的重载。而且不会有管理权转移或者说不能拷贝之类的情况。下面看一下它的运行结果。
这样的代码看起来是挺好的，但是他也有一个很严重的缺陷，那就是不能循环引用，如果循环引用的话就会出现内存泄露的问题了。为了解决这个问题我们又相应有了一个weak_ptr 智能指针，他就是专门来解决shared_ptr 中的循环引用的问题的，它不会增加引用计数。但是这个指针只能在shared_ptr中使用。
存在循环引用的shared_ptr
#include <iostream>
#include <boost/shared_ptr.hpp> //这里用到了boost库，可以自己下载一下源代码
#include <boost/weak_ptr.hpp>
using namespace std;
class parent;
class children;
typedef boost::shared_ptr<parent> parent_ptr;
typedef boost::shared_ptr<children> children_ptr;
class parent
{
public:
~parent(){
std::cout <<"destroying parent
";
}
public:
children_ptr children;
};
class children
{
public:
~children() { std::cout <<"destroying children
"; }
public:
parent_ptr parent;
};
void test()
{
parent_ptr father(new parent());
children_ptr son(new children);
father->children = son;
son->parent = father;
}
void main()
{
std::cout<<"begin test...
";
test();
std::cout<<"end test.
";
}
运行该程序可以看到：即使退出了test函数后，由于parent和children对象互相引用，它们的引用计数都是1，不能自动释放，并且此时这两个对象再无法访问到
<1>一般来讲，解除这种循环引用有下面有三种可行的方法：
1. 当只剩下最后一个引用的时候需要手动打破循环引用释放对象。
2. 当parent的生存期超过children的生存期的时候，children改为使用一个普通指针指向parent。
3. 使用弱引用的智能指针打破这种循环引用。
虽然这三种方法都可行，但方法1和方法2都需要程序员手动控制，麻烦且容易出错。
下面主要介绍一下第三种方法和boost中的弱引用的智能指针boost::weak_ptr。
<2>什么是强引用和弱引用？
一个强引用是指当被引用的对象仍活着的话，这个引用也存在（也就是说，只要至少有一个强引用，那么这个对象就不会也不能被释放）。boost::share_ptr就是强引用。
相对而言，弱引用当引用的对象活着的时候不一定存在。仅仅是当它自身存在的时的一个引用。
弱引用并不修改该对象的引用计数，这意味这弱引用它并不对对象的内存进行管理。
在功能上类似于普通指针，然而一个比较大的区别是，弱引用能检测到所管理的对象是否已经被释放，从而避免访问非法内存。
boost::weak_ptr boost::weak_ptr 是boost提供的一个弱引用的智能指针，它的声明可以简化如下：
weak_ptr
template<typename T>
class weak_ptr
{
public:
template <typename Y>
weak_ptr(const shared_ptr<Y>& r);
weak_ptr(const weak_ptr& r);
~weak_ptr();
T* get() const;
bool expired() const;
shared_ptr<T> lock() const;
};
可以看到，boost::weak_ptr必须从一个boost::share_ptr或另一个boost::weak_ptr转换而来，这也说明，进行该对象的内存管理的是那个强引用的boost::share_ptr。
boost::weak_ptr只是提供了对管理对象的一个访问手段。
boost::weak_ptr除了对所管理对象的基本访问功能（通过get()函数）外，还有两个常用的功能函数：
1. expired() 用于检测所管理的对象是否已经释放；
2. lock() 用于获取所管理的对象的强引用指针。
通过boost::weak_ptr来打破循环引用
由于弱引用不更改引用计数，类似普通指针，只要把循环引用的一方使用弱引用，即可解除循环引用。
对于上面的那个例子来说，只要把children的定义改为如下方式，即可解除循环引用：
解决循环引用的问题
class children
{
public:
~children()
{
std::cout <<"destroying children
";
}
public:
boost::weak_ptr<parent> parent;//这里改变为弱指针就好了。
}; 虽然通过弱引用指针可以有效的解除循环引用，但这种方式必须在程序员能预见会出现循环引用的情况下才能使用，也可以是说这个仅仅是一种编译期的解决方案。如果程序在运行过程中出现了循环引用，还是会造成内存泄漏的。因此，不要认为只要使用了智能指针便能杜绝内存泄漏。我们在写代码的时候尽量避免循环引用。