本文主要总结C++11中的几种智能指针的原理，使用及实现方式。
I、上帝视角看智能指针
1、智能指针的引用是为了方便堆内存管理，由于普通指针存在内存泄漏或二次释放的缺点，所以才出现了智能指针。
2、智能指针利用了RAII（资源获取即初始化）的技术，对普通指针进行封装，使得其行为像一个指针，但其实是一个对象。
II、使用智能指针
C++11中所新增的智能指针包括shared_ptr, unique_ptr, weak_ptr,在C++11之前还存在auto_ptr。
2.1 shared_ptr
1、shared_ptr多个指针指向相同的对象，使用引用计数来完成自动析构的功能。
2、shared_ptr的引用计数是线程安全的，但是其对象的写操作在多线程环境下需要加锁实现。
3、不要用同一个指针初始化多个shared_ptr，这样可能会造成二次释放。
4、shared_ptr使用实例
#include<iostream>
#include<memory>
using namespace std;
int main() {
int a = 10;
shared_ptr<int> ptra = make_shared<int>(a);
shared_ptr<int> ptra2(ptra); //拷贝构造函数
cout << ptra.use_count() << endl; //2
int b = 20;
int *pb = &b;
shared_ptr<int> ptrb = make_shared<int>(b);
ptra2 = ptrb;
pb = ptrb.get(); //获取指针
cout << ptra.use_count() << endl; //1
cout << ptrb.use_count() << endl; //2
return 0;
}
2.2 unique_ptr
1、unique_ptr 唯一拥有所指对象，同一时刻只能有一个unique_ptr指向给定对象，这是通过禁止拷贝语义、只允许移动语义来实现的。
2、unique_ptr指针本身的生命周期是从创建开始，直到离开作用域。在智能指针生命周期内，可以改变指针所指向对象，如创建智能指针时使用构造函数指定、通过reset方法重新指定、通过release方法释放所有权、通过移动语义转移所有权。
3、unique_ptr使用实例：
#include<iostream>
#include<memory>
using namespace std;
int main() {
{
unique_ptr<int> uptr(new int(10)); //绑定动态对象
unique_ptr<int> uptr2 = uptr; //不能赋值
unique_ptr<int> uptr2(uptr); //不能拷贝
unique_ptr<int> uptr2 = std::move(uptr); //转换所有权
uptr2.release(); //释放所有权
}
//超出uptr作用域，内存释放
}
2.3 weak_ptr
1、weak_ptr是为了配合shared_ptr而引入的一种智能指针，它不具备普通指针的行为，其最大的作用是协助shared_ptr工作，像旁观者那样检测资源的使用情况。
2、 weak_ptr可以从一个shared_ptr或另一个weak_ptr对象构造，获得资源的观测权。
3、weak_ptr没有共享资源，它的构造不会引起指针引用计数的增加。使用weak_ptr的成员函数use_count()可以观测资源的引用计数。
4、另一个成员函数expired()等价于判断use_count()==0。
5、lock()方法将返回一个存放空指针的shared_ptr。
6、weak_ptr使用实例：
#include<iostream>
#include<memory>
using namespace std;
int main() {
{
shared_ptr<int> sh_ptr = make_shared<int>(10);
cout << sh_ptr.use_count() << endl;
weak_ptr<int> wp(sh_ptr);
cout << wp.use_count() << endl;
if (!wp.expired()) {
shared_ptr<int> sh_ptr2 = wp.lock(); //get another shared_ptr
*sh_ptr = 100;
cout << wp.use_count() << endl;
}
}
}
III、智能指针的实现
总体来说，实现智能指针的主要任务在于实现引用计数的维护。
首先不应该直接在智能指针类中维护引用计数，这是因为如果有多个智能指针对象指向同一对象，若改变引用计数的值，需要找到这个对象的所有智能指针对象，从而改变所有的引用计数。
所以，有两个思路可以考虑：一个是使用辅助类来维护引用计数，另一个构造句柄类。
其中，辅助类采用继承的方式实现，这种方式的缺点是实现比较复杂，需要所有使用智能指针的对象都先继承自辅助类。
句柄类的方式，是在智能指针类中维护一个指向引用计数的指针，这个引用计数是一个单独的内存空间中。
3.1 智能指针类中维护引用计数
这种方法其实是不好的，若想在智能指针类中维护引用计数，应该采用构造句柄类的方式。
#include <iostream>
#include <memory>
template<typename T>
class SmartPointer {
private:
T* _ptr;
size_t* _count;
public:
SmartPointer(T* ptr = nullptr) :
_ptr(ptr) {
if (_ptr) {
_count = new size_t(1);
} else {
_count = new size_t(0);
}
}
SmartPointer(const SmartPointer& ptr) {
if (this != &ptr) {
this->_ptr = ptr._ptr;
this->_count = ptr._count;
(*this->_count)++;
}
}
SmartPointer& operator=(const SmartPointer& ptr) {
if (this->_ptr == ptr._ptr) {
return *this;
}
if (this->_ptr) {
(*this->_count)--;
if (this->_count == 0) {
delete this->_ptr;
delete this->_count;
}
}
this->_ptr = ptr._ptr;
this->_count = ptr._count;
(*this->_count)++;
return *this;
}
T& operator*() {
assert(this->_ptr == nullptr);
return *(this->_ptr);
}
T* operator->() {
assert(this->_ptr == nullptr);
return this->_ptr;
}
~SmartPointer() {
(*this->_count)--;
if (*this->_count == 0) {
delete this->_ptr;
delete this->_count;
}
}
size_t use_count(){
return *this->_count;
}
};
int main() {
{
SmartPointer<int> sp(new int(10));
SmartPointer<int> sp2(sp);
SmartPointer<int> sp3(new int(20));
sp2 = sp3;
std::cout << sp.use_count() << std::endl;
std::cout << sp3.use_count() << std::endl;
}
//delete operator
}
3.2 使用辅助类维护引用计数
具体见：https://github.com/wenmingxing1/SmartPointer
【参考】
[1] C++11中智能指针的原理、使用、实现
