智能指针

什么是智能指针

智能指针(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\n";
}
public:
children_ptr children;
};

class children
{
public:
~children() { std::cout <<"destroying children\n"; }

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...\n";
test();
std::cout<<"end test.\n";
}

运行该程序可以看到：即使退出了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\n";
}
public:
boost::weak_ptr<parent> parent;//这里改变为弱指针就好了。
};

虽然通过弱引用指针可以有效的解除循环引用，但这种方式必须在程序员能预见会出现循环引用的情况下才能使用，也可以是说这个仅仅是一种编译期的解决方案。如果程序在运行过程中出现了循环引用，还是会造成内存泄漏的。因此，不要认为只要使用了智能指针便能杜绝内存泄漏。我们在写代码的时候尽量避免循环引用。