C++学习笔记（31）：智能指针（shared_ptr）

简介

C++ 的 shared_ptr 是 C++11 标准引入的智能指针之一，用于管理动态分配的对象的所有权。它允许多个 shared_ptr 实例共享对同一对象的所有权，而不会出现内存泄漏或者悬空指针的情况。 shared_ptr 使用引用计数技术来跟踪有多少个 shared_ptr 实例指向同一个对象，并在最后一个实例销毁时自动释放对象。

shared_ptr 使用

shred_ptr 叫做共享智能指针，其创建和使用语法如下：

#if 0
#include <iostream>
#include <memory>

using namespace std;

class Person
{
public:
    Person()
    {
        cout << "无参构造函数" << endl;
    }
    Person(int, int)
    {
        cout << "有参构造函数" << endl;
    }

    ~Person()
    {
        cout << "析构函数" << endl;
    }
};

// 1. 创建 shared_ptr 对象
void test01()
{
    // 1.1 使用 shared_ptr 的构造函数创建对象
    shared_ptr<Person> sp1(new Person(10, 20));

    // 1.2 使用 shared_ptr 管理动态对象数组
    shared_ptr<Person[]> sp2(new Person[5]);
}


// 2. shared_ptr 操作函数
void test02()
{
    shared_ptr<Person> sp1(new Person(10, 20));
    shared_ptr<Person> sp2(new Person(100, 200));

    // 2.1 get 成员函数可以获得 shared_prt 管理的动态对象指针
    Person* person = sp1.get();

    // 2.2 swap 成员函数可以交换两个 shared_ptr 管理的动态对象指针
    sp1.swap(sp2);

    // 2.3 reset 成员函数存在两个重载版本的函数，其作用分别如下：
    sp1.reset();  // 释放其管理动态指针，此时 sp1 对象管理的动态指针指向为 nullptr
    sp1.reset(new Person(1, 2));  // 释放原来的动态对象，并指向新的动态对象
}

int main()
{
    test01();
    test02();

    return 0;
}

#endif

shared_ptr 特性

多个 shared_ptr 对象能够同时持有并管理同一个动态对象。当 shared_ptr 发生对象拷贝、赋值时都会导致多个 shared_ptr 对象持有同一个动态对象，如下代码所示：

#if 1
#include <iostream>
#include <memory>
#include <vector>
using namespace std;


class Person
{
public:
    Person()
    {
        cout << "无参构造函数" << endl;
    }

    ~Person()
    {
        cout << "析构函数" << endl;
    }
};

void test()
{
    shared_ptr<Person> sp1(new Person);

    // 1. 允许对象拷贝、对象赋值
    shared_ptr<Person> sp2(sp1);

    shared_ptr<Person> sp3;
    sp3 = sp1;  // 对象赋值

    // 2. 允许对象移动拷贝、移动赋值
    shared_ptr<Person> sp4 = move(sp3);

    shared_ptr<Person> sp5;
    sp5 = move(sp1);  // 移动赋值

    cout << "sp1:" << sp1.get() << endl;  // 已被移动
    cout << "sp2:" << sp2.get() << endl;
    cout << "sp3:" << sp3.get() << endl;  // 已被移动
    cout << "sp4:" << sp4.get() << endl;
    cout << "sp5:" << sp5.get() << endl;

    // 允许存储到容器中
    vector<shared_ptr<Person>> vec;
    vec.push_back(sp2);
    vec.push_back(sp4);
    vec.push_back(sp5);
}

int main()
{
    test();
    return 0;
}

#endif

shared_ptr 引用计数

shared_ptr 是通过引用计数的方式来实现对象共享的。那么，什么是引用计数呢？

在 shared_ptr 对象的内部维护了两个非常重要的内容：

1. 动态创建对象
2. 引用计数对象

请看下面的示例代码：

#if 1
#include <iostream>
#include <memory>
using namespace std;


struct Person
{
    Person()
    {
        cout << "Person 构造函数" << endl;
    }

    ~Person()
    {
        cout << "Person 析构函数" << endl;
    }
};


void test()
{
    // 初始化智能指针，引用计数为 0
    shared_ptr<Person> sp1(new Person);
    cout << "sp1:" << sp1.use_count() << endl;
    
    // 发生拷贝，引用计数 +1
    shared_ptr<Person> sp2(sp1);
    cout << "sp2:" << sp2.use_count() << endl;

    // 发生赋值，引用计数 + 1
    shared_ptr<Person> sp3;
    sp3 = sp2;
    cout << "sp3:" << sp3.use_count() << endl;
    
    // 判断是否独占资源
    cout << "sp1 是否独占资源:" << sp1.unique() << endl;

    // sp2 释放资源所有权，通过该对方访问的引用次数为 0
    sp2.reset();
    cout << "sp2:" << sp2.use_count() << endl;

    // sp1 和 sp2 引用计数为 2
    cout << "sp1:" << sp1.use_count() << endl;
    cout << "sp3:" << sp3.use_count() << endl;
}

int main()
{
    test();
    return 0;
}
#endif

shared_ptr 自定义删除器

shared_ptr 和 unique_ptr 一样，并不仅仅管理 new 出来的动态对象，但是，智能指针默认使用 delete、delete[] 来释放被管理的对象。

此时，如果被管理的对象并不是 new、new[] 出来的，需要自定义删除器。其删除器可以是以下任何一种形式：

1. 普通函数
2. 函数对象
3. lambda 匿名函数对象

请看下面的示例代码：

#if 1
#define _CRT_SECURE_NO_WARNINGS
#include <memory>
#include <iostream>
#include <memory>
using namespace std;


void my_deleter(FILE* fp)
{
    cout << "文件自动关闭" << endl;
    fclose(fp);
    fp = nullptr;
}

struct MyDeleter
{
    void operator()(FILE* fp)
    {
        cout << "文件自动关闭" << endl;
        fclose(fp);
        fp = nullptr;
    }
};


void test()
{
    // 1. 使用普通函数作为自定义删除器
    shared_ptr<FILE> sp1(fopen("./demo.txt", "w"), my_deleter);

    // 2. 使用函数对象作为自定义删除器
    shared_ptr<FILE> sp2(fopen("./demo.txt", "w"), MyDeleter());

    // 3. 使用 lambda 匿名函数对象作为自定义删除器
    shared_ptr<FILE> sp3(fopen("./demo.txt", "w"), [](FILE* fp) {
            cout << "文件自动关闭" << endl;
            fclose(fp);
            fp = nullptr;
        });
}


int main()
{
    test();
    return 0;
}

#endif