C++ 智能指针 shared_ptr 使用和示例

shared_ptr 是C++11提供的一种智能指针类，从而帮助消除内存泄漏和悬空指针的问题。

1、shared_ptr 特点

每个 shared_ptr 对象在内部有两个指针：
1、指向对象的指针。
2、用于控制引用计数数据的指针。

参考计数的作用：
1、当新的 shared_ptr 对象与指针关联时，则在其构造函数中，将与此指针关联的引用计数增加1。
2、当任何 shared_ptr 对象超出作用域时，则在其析构函数中，它将关联指针的引用计数减1。如果引用计数变为0，则表示没有其他 shared_ptr 对象与此内存关联，在这种情况下，它使用delete函数删除该内存。

2、创建 shared_ptr 对象

使用原始指针创建 shared_ptr 对象

std::shared_ptr<int> p1(new int());

上面这行代码在堆上创建了两块内存：
(1) 存储int。
(2) 用于引用计数的内存，管理附加此内存的 shared_ptr 对象的计数，最初计数将为1。

（1）检查 shared_ptr 对象的引用计数

use_count();

（2）创建空的 shared_ptr 对象

因为带有参数的 shared_ptr 构造函数是 explicit 类型的，所以不能像这样std::shared_ptr p1 = new int();隐式调用它构造函数。创建新的shared_ptr对象的最佳方法是使用std :: make_shared：

std::shared_ptr<int> p1 = std::make_shared<int>();

std::make_shared 一次性为int对象和用于引用计数的数据都分配了内存，而new操作符只是为int分配了内存。

（3）分离关联的原始指针

要使 shared_ptr 对象取消与相关指针的关联，可以使用reset()函数：
不带参数的reset()：

reset();

它将引用计数减少1，如果引用计数变为0，则删除指针。
带参数的reset()：

reset(new int(34));

在这种情况下，它将在内部指向新指针，因此其引用计数将再次变为1。
使用nullptr重置：

p1 = nullptr;

shared_ptr是一个伪指针
shared_ptr充当普通指针，我们可以将*和->与 shared_ptr 对象一起使用，也可以像其他 shared_ptr 对象一样进行比较;

完整示例

#include <iostream>
#include  <memory> // 需要包含这个头文件

int main()
{
	// 使用 make_shared 创建空对象
	std::shared_ptr<int> sp = std::make_shared<int>();
	*sp = 8;
	std::cout << "sp = " << *sp << std::endl; // 输出8

	// 打印引用个数：1
	std::cout << "sp Ref count = " << sp .use_count() << std::endl;

	// 第2个 shared_ptr 对象指向同一个指针
	std::shared_ptr<int> sp2 (sp );

	// 下面两个输出都是：2
	std::cout << "sp2 Ref count = " <<sp2.use_count() << std::endl;
	std::cout << "sp Ref count = " << sp.use_count() << std::endl;

	// 比较智能指针，p1 等于 p2
	if (sp2== sp) {
		std::cout << "point to same pointer\n";
	}

	std::cout<<"Reset sp"<<std::endl;

	// 无参数调用reset，无关联指针，引用个数为0
	sp.reset();
	std::cout << "spRef Count = " << sp.use_count() << std::endl;
	
	// 带参数调用reset，引用个数为1
	sp.reset(new int(11));
	std::cout << "sp Ref Count = " << sp.use_count() << std::endl;

	// 把对象重置为NULL，引用计数为0
	sp= nullptr;
	std::cout << "sp Ref Count = " << sp.use_count() << std::endl;
	if (!sp) {
		std::cout << "sp is NULL" << std::endl; // 输出
	}
	return 0;
}

3、自定义删除器 Deleter

当 shared_ptr 对象超出范围时，将调用其析构函数。在其析构函数中，它将引用计数减1，如果引用计数的新值为0，则删除关联的原始指针。
析构函数中删除内部原始指针，默认调用的是delete()函数。

delete Pointer;

有些时候在析构函数中，delete函数并不能满足我们的需求，可能还想加其他的处理。

当 shared_ptr 对象指向数组
std::shared_ptr sp(new int[12]);

像这样申请的数组，应该调用delete []释放内存，而shared_ptr析构函数中默认delete并不能满足需求。

(1)给shared_ptr添加自定义删除器

在上面在这种情况下，我们可以将回调函数传递给 shared_ptr 的构造函数，该构造函数将从其析构函数中调用以进行删除，即

// 自定义删除器

void delete_me(int* x)
{
	delete[] x;
}
// 构造函数传递自定义删除器指针
std::shared_ptr<int> sp(new int[12],delete_me);

下面看一个完整的示例：

#include <iostream>
#include <memory>

struct Test
{
    Test() { std::cout << "Test\n";}
    ~Test() { std::cout << "~Test\n";}
};

void deleter(Test* x)
{
    std::cout << "Custom Deleter\n";
    delete[] x;
}

int main()
{
    std::shared_ptr<Test> sp(new Test[3], delete_me);
    return 0;
}

使用Lambda 表达式 / 函数对象作为删除器

class DeleteMe
{
	public:
	void operator() (Test* x) {
		std::cout<<"DeleteMe\n";
		delete[] x;
	}
};

// 函数对象作为删除器
std::shared_ptr<Test> sp(new Test[3], DeleteMe());

// Lambda表达式作为删除器
std::shared_ptr<Test> sp1(new Test[3], [&](Test* x){
	std::cout<<"Lambda delete\n";
		delete[] x;
});

shared_ptr 相对于普通指针的优缺点:
(1) 缺少 ++, – – 和 [] 运算符；
(2) 与普通指针相比，shared_ptr仅提供-> 、*和==运算符，没有+、-、++、–、[]等运算符。

4、NULL检测

当创建 shared_ptr 对象不分配任何值时，它就是空的；普通指针不分配空间的时候相当于一个野指针，指向垃圾空间，且无法判断指向的是否是有用数据。
shared_ptr 检测空值方法

std::shared_ptr<Test> test;
if(!test)
	std::cout<<"Yes, testis empty" << std::endl;
if(test== NULL)
	std::cout<<"testis empty" << std::endl;
if(test== nullptr)
	std::cout<<"testis empty" << std::endl;

5、使用shared_ptr 时注意事项:

（1）不要使用同一个原始指针构造 shared_ptr

创建多个 shared_ptr 的正常方法是使用一个已存在的shared_ptr 进行创建，而不是使用同一个原始指针进行创建。
示例：

int *num = new int(23);
std::shared_ptr<int> p1(num);

std::shared_ptr<int> p2(p1);  // 正确使用方法
std::shared_ptr<int> p3(num); // 错误方法，重复卸载

假如使用原始指针num创建了p1，又同样方法创建了p3，当p1超出作用域时会调用delete释放num内存，此时num成了悬空指针，当p3超出作用域再次delete的时候就可能会出错。

（2）不要用栈中的指针构造 shared_ptr 对象

shared_ptr 默认的构造函数中使用的是delete来删除关联的指针，所以构造的时候也必须使用new出来的堆空间的指针。
示例：

   int x = 12;
   std::shared_ptr<int> sp(&x);

当 shared_ptr 对象超出作用域调用析构函数delete 指针&x时会出错。

（3）建议使用 make_shared

为了避免以上两种情形，建议使用make_shared()<>创建 shared_ptr 对象，而不是使用默认构造函数创建。

std::shared_ptr<int> ptr_1 = make_shared<int>();
std::shared_ptr<int> ptr_2 (ptr_1);

（4）小心使用get()函数

另外小心使用get()函数获取 shared_ptr 关联的原始指针，因为如果在 shared_ptr 析构之前手动调用了delete函数，同样会导致类似的错误。