C++智能指针 shared_ptr 精简 教程

C++智能指针 shared_ptr

shared_ptr 是一个标准的共享所有权的智能指针, 允许多个指针指向同一个对象. 定义在 memory 文件中(非memory.h), 命名空间为 std.

shared_ptr是Boost库所提供的一个智能指针的实现,shared_ptr就是为了解决auto_ptr在对象所有权上的局限性（auto_ptr是独占的），在使用引用计数的机制上提供了可以共享所有权的智能指针, 当然这需要额外的开销

shared_ptr是C++标准库的一部分，它在C++11中被纳入标准库。但是，shared_ptr的设计思想和初期的实现实际上来源于Boost库。Boost库是一个广受欢迎的C++库，它包含了许多高质量的、可重用的C++组件。这些组件中的一些，包括shared_ptr，最终被纳入C++标准库。所以，当人们谈论shared_ptr时，他们可能会提到它的历史，即它起源于Boost库，但现在是C++标准库的一部分。

shared_ptr是可以拷贝和赋值的，拷贝行为也是等价的，并且可以被比较，这意味这它可被放入标准库的一般容器（vector，list）和关联容器中（map）

• shared_ptr 对象除了包括一个所拥有对象的指针外, 还必须包括一个引用计数代理对象的指针.
• 时间上的开销主要在初始化和拷贝操作上, *和->操作符重载的开销跟auto_ptr是一样.
• 开销并不是我们不使用shared_ptr的理由, 永远不要进行不成熟的优化, 直到性能分析器告诉你这一点.

成员函数

1. use_count 返回引用计数的个数
2. unique 返回是否是独占所有权( use_count 为 1)
3. swap 交换两个 shared_ptr 对象(即交换所拥有的对象)
4. reset 放弃内部对象的所有权或拥有对象的变更, 会引起原有对象的引用计数的减少
5. get 返回内部对象(指针), 由于已经重载了()方法, 因此和直接使用对象是一样的.如 shared_ptr sp(new int(1)); sp 与 sp.get()是等价的

使用shared_ptr注意事项

1. 不要把一个原生指针给多个shared_ptr管理；
2. 不要把this指针给shared_ptr；
3. 不要在函数实参里创建shared_ptr；
4. 不要不加思考地把指针替换为shared_ptr来防止内存泄漏，shared_ptr并不是万能的，而且使用它们的话也是需要一定的开销的；
5. 环状的链式结构shared_ptr将会导致内存泄漏(可以结合weak_ptr来解决)；
6. 共享拥有权的对象一般比限定作用域的对象生存更久，从而将导致更高的平均资源使用时间；
7. 在多线程环境中使用共享指针的代价非常大，这是因为你需要避免关于引用计数的数据竞争；
8. 共享对象的析构器不会在预期的时间执行；
9. 不使用相同的内置指针值初始化(或reset)多个智能指针；
10. 不delete get()返回的指针；
11. 不使用get()初始化或reset另一个智能指针；
12. 如果使用get()返回的指针，记住当最后一个对应的智能指针销毁后，你的指针就变为无效了；
13. 如果你使用智能指针管理的资源不是new分配的内存，记住传递给它一个删除器。

使用方法

可以使用模板函数 make_shared 创建对象, make_shared 需指定类型('<>‘中)及参数(’()'内), 传递的参数必须与指定的类型的构造函数匹配. 如:

std::shared_ptr<int> sp1 = std::make_shared<int>(10);
　　std::shared_ptr<std::string> sp2 = std::make_shared<std::string>("Hello c++");

也可以定义 auto 类型的变量来保存 make_shared 的结果.

auto sp3 = std::make_shared<int>(11);
　　printf("sp3=%d\n", *sp3);
　　auto sp4 = std::make_shared<std::string>("C++11");
　　printf("sp4=%s\n", (*sp4).c_str());

定制shared_ptr删除器

在某些情况下，你可能需要定制 shared_ptr 的删除器。删除器是一个函数或函数对象，在 shared_ptr 释放其所持有的对象时被调用。默认情况下，shared_ptr 使用 delete 来释放对象。但是，如果你需要使用其他方式来释放对象，例如，如果对象是用 malloc 创建的，或者对象是一个文件或者网络连接，你就需要定制删除器。

这是一个如何定制 shared_ptr 删除器的教程：

首先，让我们定义一个删除器。在这个例子中，我们将定制一个删除器来关闭文件：

struct FileDeleter
{
    void operator()(FILE* ptr) const
    {
        if (ptr)
        {
            std::cout << "Closing file" << std::endl;
            fclose(ptr);
        }
    }
};

注意，删除器必须是一个函数对象，也就是说，它必须定义 operator()。删除器将接收一个指向 shared_ptr 所持有对象的指针。

然后，你可以创建一个 shared_ptr，并指定删除器：

std::shared_ptr<FILE> sp(fopen("test.txt", "w"), FileDeleter());

在这里，我们打开一个文件，并将文件指针传递给 shared_ptr。我们也将我们的删除器 FileDeleter 传递给 shared_ptr。这样，当 shared_ptr 需要释放文件指针时，它将调用 FileDeleter。

你也可以使用 make_shared 创建 shared_ptr，但是注意 make_shared 不接受删除器。所以，如果你需要定制删除器，你需要直接使用 shared_ptr 的构造函数。

最后，当 shared_ptr 的引用计数变为 0，它将释放其所持有的文件指针，并调用 FileDeleter。

以上就是如何定制 shared_ptr 删除器的全部内容。通过定制删除器，你可以让 shared_ptr 适应更多的场景，包括管理不同类型的资源，如文件、网络连接，甚至可以与 C 语言的代码兼容。

何时需要使用 shared_ptr ?

• 程序不知道自己需要使用多少对象. 如使用窗口类, 使用 shared_ptr 为了让多个对象能共享相同的底层数据.
• 程序不知道所需对象的准确类型.
• 程序需要在多个对象间共享数据.

智能指针shared_ptr的应用场景

• 场景一: 有多个使用者共同使用同一个对象，而这个对象没有一个明确的拥有者.
  这就好比教室里的电灯，大家都在使用这个电灯，但没有那个人来专门负责这个电灯的开关。往往是教室里一个人都没有，电灯却明晃晃地亮着。在这种场景下，我们就可以使用shared_ptr来管理这个电灯，通过shared_ptr，谁都可以使用这个电灯，但谁最后使用电灯谁就负责最后关灯。
• 场景二: 某一个对象的复制操作很费时.
  如果一个对象的复制操作很费时，同时我们又需要在函数间传递这个对象，我们往往会选择传递指向这个对象的指针来代替传递对象本身，以此来避免对象的复制操作。
  既然选择使用指针，那么使用shared_ptr是一个更好的选择，即起到了向函数传递对象的作用，又不用为释放对象操心。

• 场景三: 要把指针存入标准库容器.
  不管容器中保存的是普通指针还是智能指针，在使用上，两者并无太大区别，使用智能指针的优越性主要体现在容器使用完毕后清空容器的操作上。如果容器中保存的是普通指针，当我们在清空某个容器时，先要释放容器中指针所指向的资源，然后才能清空这些指针本身。例如，在SalarySys类的析构函数中，我们需要清空vecEmp容器中保存的Employee*指针：

• 场景四: 当管理需要特殊清除方式的资源时，可以通过定制shared_ptr的删除器来实现.

在这个例子中，我们创建一个 Student 类，然后使用 std::shared_ptr 来管理 Student 对象。我们将演示如何使用 std::shared_ptr 在多个对象间共享数据。

#include <iostream>
#include <memory>
#include <vector>
// 假设我们有一个 Student 类，它有一个名字和一个成绩。
class Student {
public:
    Student(const std::string& name, int grade) : name(name), grade(grade) {}
    ~Student() {
        std::cout << "Student " << name << " is destroyed" << std::endl;
    }
    std::string name;
    int grade;
};
int main() {
    // 创建一个 std::shared_ptr，管理一个新的 Student 对象。
    std::shared_ptr<Student> s1 = std::make_shared<Student>("John", 90);
    // 输出引用计数 (应为 1)
    std::cout << "s1 use count: " << s1.use_count() << std::endl;
    // 创建一个新的 std::shared_ptr，管理同一个 Student 对象。
    std::shared_ptr<Student> s2 = s1;
    // 输出引用计数 (现在应为 2，因为 s1 和 s2 都在引用同一个对象)
    std::cout << "s1 use count: " << s1.use_count() << std::endl;
    std::cout << "s2 use count: " << s2.use_count() << std::endl;
    // 将 s1 添加到一个 vector 中
    std::vector<std::shared_ptr<Student>> vec;
    vec.push_back(s1);
    // 输出引用计数 (现在应为 3，因为 s1、s2 和 vector 中的元素都在引用同一个对象)
    std::cout << "s1 use count: " << s1.use_count() << std::endl;
    std::cout << "s2 use count: " << s2.use_count() << std::endl;
    // 当我们清空 vector 时，vector 中的元素将被销毁，引用计数减 1。
    vec.clear();
    // 输出引用计数 (现在应为 2)
    std::cout << "s1 use count: " << s1.use_count() << std::endl;
    std::cout << "s2 use count: " << s2.use_count() << std::endl;
    return 0;
}

在这个例子中，std::shared_ptr 确保了只要有任何对象仍然需要 Student 对象，该对象就不会被删除。只有当所有的 std::shared_ptr 都不再需要 Student 对象时，对象才会被删除。这种行为可以防止因提前删除对象而引发的问题。同时，通过 use_count 成员函数，我们可以查看当前有多少个 std::shared_ptr 在管理同一个对象。