【Smart_Point】C/C++ 中共享指针 shared_ptr

1. 共享指针 shared_ptr

目录

1. 共享指针 shared_ptr

1.1 共享指针解决的问题？

1.2 创建 shared_ptr 对象

1.3 分离关联的原始指针

1.4 自定义删除器 Deleter

1.5 shared_ptr 相对于普通指针的优缺点

1.6 创建 shared_ptr 时注意事项

1.1 共享指针解决的问题？

shared_ptr 是C++11提供的一种智能指针类（ 智能指针是一个可以像指针一样工作的对象，但是当它不再被使用时，可以自动删除动态分配的内存）。它足够智能，可以在任何地方都不使用时自动删除相关指针，从而帮助彻底消除内存泄漏（ 也就是说，即使已经不再需要内存了，但指针仍然未被删除。另外还有双重删除的问题，当程序的某部分要删除一个已经被删除的指针时，即可出现这种情况。如果被删除的内存已经进行了重新分配，则双重删除会对程序造成破坏。）和悬空指针（ 指针已经被删除了，但其内存仍然在使用中 ）的问题。 它遵循共享所有权的概念，即不同的 shared_ptr 对象可以与相同的指针相关联，并在内部使用引用计数机制来实现这一点。 每个 shared_ptr 对象在内部指向两个内存位置： 1、指向对象的指针。 2、用于控制引用计数数据的指针。 共享所有权如何在参考计数的帮助下工作： 1、当新的 shared_ptr 对象与指针关联时，则在其构造函数中，将与此指针关联的引用计数增加1。 2、当任何 shared_ptr 对象超出作用域时，则在其析构函数中，它将关联指针的引用计数减1。如果引用计数变为0，则表示没有其他 ~对象与此内存关联，在这种情况下，它使用delete函数删除该内存。

1.2 创建 shared_ptr 对象

1.2.1 使用原始指针创建 shared_ptr 对象

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

上面这行代码在堆上创建了两块内存：

1：存储int。

2：用于引用计数的内存，管理附加此内存的 shared_ptr 对象的计数，最初计数将为1。

检查 shared_ptr 对象的引用计数

p1.use_count();

创建空的 shared_ptr 对象

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

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

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

1.3 分离关联的原始指针

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

p1.reset();

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

p1.reset(new int(34));

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

p1 = nullptr; 

shared_ptr是一个伪指针，本质类

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

1.3.2 完整示例

#include <iostream>
#include  <memory> // 需要包含这个头文件
​
int main()
{// 使用 make_shared 创建空对象std::shared_ptr<int> p1 = std::make_shared<int>();*p1 = 78;std::cout << "p1 = " << *p1 << std::endl; // 输出78
​// 打印引用个数：1std::cout << "p1 Reference count = " << p1.use_count() << std::endl;
​// 第2个 shared_ptr 对象指向同一个指针std::shared_ptr<int> p2(p1);
​// 下面两个输出都是：2std::cout << "p2 Reference count = " << p2.use_count() << std::endl;std::cout << "p1 Reference count = " << p1.use_count() << std::endl;
​// 比较智能指针，p1 等于 p2if (p1 == p2) {std::cout << "p1 and p2 are pointing to same pointer\n";}
​std::cout<<"Reset p1 "<<std::endl;
​// 无参数调用reset，无关联指针，引用个数为0p1.reset();std::cout << "p1 Reference Count = " << p1.use_count() << std::endl;// 带参数调用reset，引用个数为1p1.reset(new int(11));std::cout << "p1  Reference Count = " << p1.use_count() << std::endl;
​// 把对象重置为NULL，引用计数为0p1 = nullptr;std::cout << "p1  Reference Count = " << p1.use_count() << std::endl;if (!p1) {std::cout << "p1 is NULL" << std::endl; // 输出}return 0;
}

输出结果

p1 = 78
p1 Reference count = 1
p2 Reference count = 2
p1 Reference count = 2
p1 and p2 are pointing to same pointer
Reset p1 
p1 Reference Count = 0
p1  Reference Count = 1
p1  Reference Count = 0
p1 is NULL

1.4 自定义删除器 Deleter

1.4.1 下面将讨论如何将自定义删除器与 std :: shared_ptr 一起使用。

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

delete Pointer;

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

当 shared_ptr 对象指向数组

std::shared_ptr<int> p3(new int[12]);
像这样申请的数组，应该调用delete []释放内存，而shared_ptr析构函数中默认delete并不能满足需求。

给shared_ptr添加自定义删除器

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

// 自定义删除器
void deleter(Sample * x)
{std::cout << "DELETER FUNCTION CALLED\n";delete[] x;
}
// 构造函数传递自定义删除器指针
std::shared_ptr<Sample> p3(new Sample[12], deleter);

完整的示例：

#include <iostream>
#include <memory>struct Sample
{Sample() {std::cout << "Sample\n";}~Sample() {std::cout << "~Sample\n";}
};void deleter(Sample * x)
{std::cout << "Custom Deleter\n";delete[] x;
}int main()
{std::shared_ptr<Sample> p3(new Sample[2], deleter);return 0;
}

输出结果：

Sample
Sample
Custom Deleter
~Sample
~Sample

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

class Deleter
{public:void operator() (Sample * x) {std::cout<<"DELETER FUNCTION CALLED\n";delete[] x;}
};// 函数对象作为删除器
std::shared_ptr<Sample> p3(new Sample[3], Deleter());// Lambda表达式作为删除器，无需依赖/调用实现class Deleter类
std::shared_ptr<Sample> p4(new Sample[3], [](Sample * x){std::cout<<"DELETER FUNCTION CALLED\n";delete[] x;
});

1.5 shared_ptr 相对于普通指针的优缺点

缺少 ++, – – 和 [] 运算符

与普通指针相比，shared_ptr仅提供-> 、*和==运算符，没有+、-、++、--、[]等运算符。 示例：

#include<iostream>
#include<memory>struct Sample {void dummyFunction() {std::cout << "dummyFunction" << std::endl;}
};int main()
{std::shared_ptr<Sample> ptr = std::make_shared<Sample>();(*ptr).dummyFunction(); // 正常ptr->dummyFunction(); // 正常// ptr[0]->dummyFunction(); // 错误方式// ptr++;  // 错误方式//ptr--;  // 错误方式std::shared_ptr<Sample> ptr2(ptr);if (ptr == ptr2) // 正常std::cout << "ptr and ptr2 are equal" << std::endl;return 0;
}

NULL检测

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

std::shared_ptr<Sample> ptr3;
if(!ptr3)std::cout<<"Yes, ptr3 is empty" << std::endl;
if(ptr3 == NULL)std::cout<<"ptr3 is empty" << std::endl;
if(ptr3 == nullptr)std::cout<<"ptr3 is empty" << std::endl;

1.6 创建 shared_ptr 时注意事项

1.6.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); // 不推荐std::cout << "p1 Reference = " << p1.use_count() << std::endl; // 输出 2std::cout << "p2 Reference = " << p2.use_count() << std::endl; // 输出 2std::cout << "p3 Reference = " << p3.use_count() << std::endl; // 输出 1

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

1.6.2 不要用栈中的指针构造 shared_ptr 对象

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

#include<iostream>
#include<memory>int main()
{int x = 12;std::shared_ptr<int> ptr(&x);return 0;
}

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

1.6.3 建议使用 make_shared

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

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

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