智能指针之 shared_ptr 的使用

一、智能指针

1. 什么是智能指针

简单地说，C++智能指针是包含重载运算符的类，其行为像常规指针，但智能指针能够及时、妥善地销毁动态分配的数据，并实现了明确的对象生命周期，因此更有价值。

2. 常规指针存在的问题

C++在内存分配、释放和管理方面向程序猿提供了全面的灵活性。但是这种灵活性是把双刃剑，一方面它使C++成为一种功能强大的语言，另一方面它让程序猿能够制造与内存相关的问题，比如内存泄漏。
例如在堆声明和分配的内存，析构方法是否会自动销毁对象，又或是方法结束后需要一个个释放，方法存在很多返回的地方，每个返回语句都要执行很多相关释放操作，十分繁琐，用智能指针就能实现其自动释放。

3. 智能指针有何帮助

鉴于使用常规指针存在的问题，当 C++ 程序猿需要管理堆中的数据时，可使用智能指针的方式分配和管理内存。

4. 智能指针是如何实现的

智能指针类重载了解除引用运算符（*）和成员选择运算符（->）。
同时为了能够在堆中管理各种类型，几乎所有的智能指针都是模板类，包含其功能的泛型实现。

二、shared_ptr 简介

1. 概念

shared_ptr 是一种定义在 <memory> 中的智能指针(smart pointer)。和 unique_ptr 不同，它允许多个指针指向同一个对象。
由于旧的 auto_ptr 存在一些问题：不能指向数组，不能共享所有权，不能通过复制操作初始化，不能放入容器中使用，不能作为容器成员，容易重复 delete 对象…
所以新设计的 shared_ptr 取代了 auto_ptr，任何时候我们都应该使用 shared_ptr 而不是 auto_ptr。

2. 原理

shared_ptr 使用引用计数的概念，每当一个指针指向同一个对象时，计数加一。在 shared_ptr 析构的时候，当且仅当计数为零时才会去删除指向的对象资源，否则只是将计数减一。

3. 示例

下面简单演示了一下 shared_ptr 的使用。注意当我们使用一个对象资源创建智能指针后，后续的操作应该都是通过这个智能指针来进行。

#include <iostream>
#include <memory>

int main() {
    int* i = new int(1);

    std::shared_ptr<int> p1(i); // 创建共享指针 p1
    std::cout << "p1 count: " << p1.use_count() << "\n"; // count: 1
    {
        std::shared_ptr<int> p2(p1); // 创建共享指针 p2，它和 p1 共享一个引用计数器，计数加一
        std::cout << "p1 count: " << p1.use_count() << "\n"; // count: 2
        std::cout << "p2 count: " << p2.use_count() << "\n"; // count: 2
        // 离开作用域，p2 被析构，计数减一
    }
    std::cout << "p1 count: " << p1.use_count() << "\n"; // count: 1

    std::shared_ptr<int> p3(i); // 注意：创建共享指针 p3，这样写的话没有和 p1 共享引用计数器
    std::cout << "p1 count: " << p1.use_count() << "\n"; // count: 1
    std::cout << "p3 count: " << p3.use_count() << "\n"; // count: 1
    // 注意：这样对象 i 将在 p1 和 p3 析构的时候释放两次而出错！
    return 0;
}

三、shared_ptr 各方法介绍

1. 构建方法

#include <iostream>
#include <memory>

struct C { int* data; };

int main() {
	std::shared_ptr<int> p1;
	std::shared_ptr<int> p2(nullptr);
	std::shared_ptr<int> p3(new int);
	std::shared_ptr<int> p4(new int, std::default_delete<int>());
	std::shared_ptr<int> p5(new int, [](int* p) {delete p; }, std::allocator<int>());
	std::shared_ptr<int> p6(p5);
	std::shared_ptr<int> p7(std::move(p6));
	std::shared_ptr<int> p8(std::unique_ptr<int>(new int));
	std::shared_ptr<C> obj(new C);
	std::shared_ptr<int> p9(obj, obj->data);
	// make_shared函数的主要功能是在动态内存中分配一个对象并初始化它，并返回指向此对象的shared_ptr
	std::shared_ptr<int> p10 = std::make_shared<int>(1);

	std::cout << "use_count:\n";
	std::cout << "p1: " << p1.use_count() << '\n'; // 0
	std::cout << "p2: " << p2.use_count() << '\n'; // 0
	std::cout << "p3: " << p3.use_count() << '\n'; // 1
	std::cout << "p4: " << p4.use_count() << '\n'; // 1
	std::cout << "p5: " << p5.use_count() << '\n'; // 2
	std::cout << "p6: " << p6.use_count() << '\n'; // 0
	std::cout << "p7: " << p7.use_count() << '\n'; // 2
	std::cout << "p8: " << p8.use_count() << '\n'; // 1
	std::cout << "p9: " << p9.use_count() << '\n'; // 2
	std::cout << "p10: " << p10.use_count() << '\n'; // 1
}

2. use_count() 获取引用计数个数

3. unique() 返回是否独占，即判断 use_count 是否为 1

4. swap() 交换两个 shared_ptr 拥有的对象

5. reset() 放弃内部对象的拥有权，即原对象的引用计数减一

四、自定义删除器

我们可以为 shared_ptr 设置要使用的删除器，即对象释放时需要执行的方法。

#include <iostream>
#include <memory>

class A {};

void Deleter(A* obj) {
	delete obj; // 删除对象指针，根据具体需求改写释放的实现
}

int main() {
	std::shared_ptr<int> p1(new int[10], [](int *p) {delete[] p; }); // 删除数组一定要使用 delete[]
	std::shared_ptr<A> p2(new A, Deleter); // 使用指定的删除器
}

五、其它

1. unique_ptr

当资源对象只需要被引用一次，推荐使用 unique_ptr。关于 unique_ptr 可以参见：

https://blog.csdn.net/afei__/article/details/80670283

2. weak_ptr

weak_ptr 的出现是伴随 shared_ptr 而来的，专门用于解决 循环引用 带来的内存泄漏的问题。

当两个 shared_ptr 互相引用的时候，将导致循环引用的问题，造成无法释放产生内存泄漏。

通过将其中一个 shared_ptr 替换为 weak_ptr 可解决该问题，因为 weak_ptr 不会增加引用计数。