C++11: 智能指针

（一）智能指针原理

我们在编写代码时，会因为各种问题而没有做到内存释放，造成内存泄漏的问题。
即使我们对申请的内存空间记着匹配的去释放，但是如果碰上异常时，就算注意释放了，还是可能会出问题。

因此我们采用RAII思想或者智能指针来管理资源

1.RAll

RAII是什么:

• RAII是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。

这种做法有两大好处：

• 不需要显式地释放资源。
• 采用这种方式，对象所需的资源在其生命期内始终保持有效。

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:SmartPtr(T* ptr = nullptr): _ptr(ptr){}~SmartPtr(){if(_ptr)delete _ptr;}private:T* _ptr;
};

2.智能指针

上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容。因此我们还需要将* 、->重载下，才可让其像指针一样去使用。

template<class T>
class SmartPtr {
public:SmartPtr(T* ptr = nullptr): _ptr(ptr){}~SmartPtr(){if (_ptr)delete _ptr;}T& operator*() { return *_ptr; }T* operator->() { return _ptr; }
private:T* _ptr;
};

总结一下智能指针的原理：

• RAII特性
• 重载operator*和opertaor->，具有像指针一样的行为。

(二)C++11 智能指针

1. auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。auto_ptr的实现原理：管理权转移的思想。

• 下面简化模拟实现了一份xrw::auto_ptr来了解它的原理

namespace xrw
{template<class T>class auto_ptr{public:auto_ptr(T* ptr):_ptr(ptr){}~auto_ptr(){if (_ptr){delete _ptr;}}auto_ptr(const auto_ptr<T>& sp):_ptr(sp._ptr){sp._ptr = nullptr;}auto_ptr& operator=(const auto_ptr<T>& sp){if (_ptr != sp._ptr){if (_ptr){delete _ptr;}_ptr = sp._ptr;sp._ptr = nullptr;}return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
}

实际上，auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr。
因为当一个对象的管理权转移后，该对象不能再用对原来管理的资源进行访问，否则程序就会崩溃。

---

2. unique_ptr

unique_ptr的实现原理：简单粗暴的防拷贝

下面简化模拟实现unique_ptr

namespace xrw
{template<class T>class unique_ptr{public:unique_ptr(T* ptr):_ptr(ptr){}~unique_ptr(){if (_ptr){cout << "delete:" << _ptr << endl;delete _ptr;}}// 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}unique_ptr(const unique_ptr<T>&sp) = delete;unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;private:T* _ptr;};
}

该智能指针简单粗暴，但是不能实现拷贝赋值的操作。

---

3. shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr.
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

• shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享
• 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减1。
• 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源
• 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

下面是shared_ptr的一个简化的模拟实现

设计思路：
这里提供一个整形指针_count来进行引用计数，当进行拷贝赋值等操作时，我们只需要这个指针的地址拷贝过去，然后将这个指针所指向的内容加1即可。若当进行析构时，对_count所指向的内容减1，并且判断*_count是否等于0，若等于0才真正的进行内存释放

template<class T>
class shared_ptr
{
public:private:T* _ptr;int* _count;  //引用计数
};

整体代码：

	template<class T>
class shared_ptr
{
public:shared_ptr(T* ptr):_ptr(ptr), _count(new int(1)){}~shared_ptr(){if (--(*_count) == 0){delete _ptr;delete _count;}}shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr), _count(sp._count){++(*_count);}shared_ptr& operator=(const shared_ptr<T>& sp){if (--(*_count) == 0){delete _ptr;delete _count;}_ptr = sp._ptr;_count = sp._count;++(*_count);}T* get() const{return _ptr;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;int* _count;
};

---

4. weak_ptr

weak_ptr的存在就是为了解决shared_ptr的循坏引用的问题，它能对shared_ptr对象的资源进行控制，但是不参与引用计数的计算。

下面是weak_ptr的简化模拟实现

template<class T>
class weak_ptr
{
public:weak_ptr():_ptr(nullptr){}weak_ptr(const shared_ptr<T>& sp):_ptr(sp.get()){}weak_ptr& operator= (const shared_ptr<T>& sp){_ptr = sp.get();return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};

（三）shared_ptr中存在的问题

std::shared_ptr的循环引用

template<class T>
class weak_ptr
{
public:weak_ptr():_ptr(nullptr){}weak_ptr(const shared_ptr<T>& sp):_ptr(sp.get()){}weak_ptr& operator= (const shared_ptr<T>& sp){_ptr = sp.get();return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};

struct ListNode
{int _data;shared_ptr<ListNode> _prev;shared_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }
};int main()
{shared_ptr<ListNode> node1(new ListNode);shared_ptr<ListNode> node2(new ListNode);cout << node1.use_count() << endl;cout << node2.use_count() << endl;node1->_next = node2;node2->_prev = node1;cout << node1.use_count() << endl;cout << node2.use_count() << endl;return 0;
}

循环引用分析：

1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
4. 也就是说_next析构了，node2就释放了。
5. 也就是说_prev析构了，node1就释放了。
6. 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev
   属于node2成员，所以这就叫循环引用，谁也不会释放。
   

那么我们如何解决上面的问题呢？
在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了

struct ListNode
{int _data;weak_ptr<ListNode> _prev;weak_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }
};int main()
{shared_ptr<ListNode> node1(new ListNode);shared_ptr<ListNode> node2(new ListNode);cout << node1.use_count() << endl;cout << node2.use_count() << endl;node1->_next = node2;node2->_prev = node1;cout << node1.use_count() << endl;cout << node2.use_count() << endl;return 0;
}

weak_ptr不参与引用计数。

（四）删除器

上面的模拟实现的shared_ptr代码中我们都默认是 new出来的对象通过智能指针管理，但要是不是new出来的对象我们如果处理呢？因此我们引入了一个删除器。

其实删除器的本质和仿函数类似，我们提供一个包装器对象，该对象用来接收（仿函数，lambda表达式等）特等的删除方式。

template<class T>
class shared_ptr
{
public:private:T* _ptr;int* _count;function <void(T*)> _del = [](T* ptr) {delete ptr; };
};

因此当我们不能只用delete来释放内存的情况出现时，使用shared_ptr智能指针就必须要主动提供一个仿函数（可以是lambda表达式等）来处理删除的情况。

• 所以我们需要提供一个构造函数来接受这个仿函数

template<class D>
shared_ptr(T* ptr,D del):_ptr(ptr), _count(new int(1)),_del(del)
{}

对此删除器我们需要做出改动的就只有析构，拷贝，赋值函数，其实就是将原有的delete，变成调用删除器罢了

~shared_ptr()
{if (--(*_count) == 0){_del(_ptr);delete _count;}
}shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr), _count(sp._count), _del(sp._del)
{++(*_count);
}shared_ptr& operator=(const shared_ptr<T>& sp)
{if (--(*_count) == 0){_del(_ptr);delete _count;}_ptr = sp._ptr;_count = sp._count;++(*_count);
}

用包装器的思路来处理删除器十分巧妙。

下面是使用这个删除器的例子：

class A
{
public:A(int a = 0):_a(a){cout << "A(int a = 0)" << endl;}~A(){cout << this;cout << " ~A()" << endl;}//private:int _a;
};template<class T>
struct DeleteArray
{void operator()(T* ptr){delete[] ptr;}
};int main()
{xrw::shared_ptr<A> sp1(new A[10], DeleteArray<A>());xrw::shared_ptr<A> sp2((A*)malloc(sizeof(A)), [](A* ptr) {free(ptr); });xrw::shared_ptr<A> sp3(new A);  //这里是new一个对象，可以使用默认的deletereturn 0;
}

（五）C++11和boost中智能指针的关系

1. C++ 98 中产生了第一个智能指针auto_ptr.
2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。