【C++深陷】之shared_ptr

0. 什么是智能指针

使用new 和delete 手动进行动态内存管理很容易出现内存泄漏等问题。C++11为了更安全、更方便的管理动态内存，新的标准库提供了两种智能指针（smart pointer）：shared_ptr和unique_ptr，以及一个伴随类weak_ptr。

这三种类型定义在memory头文件中。

当指向某对象的最后一个shared_ptr被销毁时，shared_ptr类会自动帮助我们销毁开辟的动态内存。unique_ptr因为独占所指向的对象，不允许拷贝、赋值等操作，在其被销毁时也会帮助我们自动的销毁动态内存。

本文主要介绍shared_ptr。

1. 创建与初始化

智能指针也是类模板，因此需要尖括号指定指针的类型。

#include <memory>

int main() {
    std::shared_ptr<string> p1; // 可以指向string, 但此时指针的值是未初始化的未定义值，依旧不安全
    std::shared_ptr<list<int>>p2; // 可以指向int的list
    return 0;
}

可以使用标准库函数std::make_shared进行声明和初始化，是一种更加安全的方式。

auto p3 = std::make_shared<string>(10, 's'); // p3指向一个string, string的值是「ssssssssss」
std::cout << p3 << " -> " << *p3; // 输出: 0x7fa9d6904098 -> ssssssssss

智能指针完全可以当做正常指针使用，直接使用*解引用运算符可以直接得到指针指向的值。

2. 使用

shared_ptr就是一个类模板，通过运算符重载、构造函数、析构函数等C++面向对象的特性，外加引用计数规则，将动态内存管理这件事情屏蔽给了编程者。

shared_ptr支持的操作不多，*和->可以把智能指针当做原生指针一样使用。其他的属于shared_ptr类的操作。

可以直接跑下面的例子。

#include <iostream>
#include <memory>

int main() {
    auto smart_ptr = std::make_shared<std::string>(10, 's');
	
	// 不能像如下形式的赋值初始化
	// std::shared_ptr<string> p0 = new string(10, 's');
	// 必须显示调用
	
	// p1也指向一个动态内存, 内存是一个string, string的内容是「ssssssssss」
    auto p1(smart_ptr);

    // 解引用运算符访问对象, 输出: 0x7fa9d6904098 -> ssssssssss
    std::cout << smart_ptr << " -> " << *smart_ptr << std::endl;

    // 箭头运算符调用对象函数, 等价于 (*.smart_ptr).size(), 调用string的size函数
    // 输出: 10
    std::cout << smart_ptr->size() << std::endl;

    // 这里就不能用 nullptr == smart_ptr 判断了
    if (smart_ptr) {
        std::cout << "指针有效" << std::endl; // 输出
    } else {
        std::cout << "指针无效" << std::endl;
    }

    auto p2 = smart_ptr;
    // 输出: 3, 0
    std::cout << smart_ptr.use_count() << ", " << smart_ptr.unique() << std::endl;
    // use_count为1, unique返回true, 否则返回false; 这里输出的时候讲bool类型转换为int类型了
    
    // get方法得到裸指针类型, !!!尽量不要使用
    std::string *p0 = smart_ptr.get();

    // 退出程序的时候不用delete smart_ptr
    // 会自动销毁
    
    return 0;
}

3. 引用计数原理

一共4个关键点：

1. 构造函数，引用计数初始化为1
2. 拷贝构造函数，引用计数 +1
3. 赋值运算符, 右边引用计数 +1，左边原来指向的对象 -1。若左侧的原来指向的对象引用计数归0，则清理原来对象的内存
4. 退出作用域后，清理局部变量，调用智能指针的析构函数，引用计数 -1。若引用计数归0, 在析构函数中清理内存

int main() {
    // 1. 构造函数, 引用计数初始化为1
    std::shared_ptr<std::string> p0(new std::string("str0"));
    std::shared_ptr<std::string> p1(new std::string("str1"));

    // 输出: 「str0: 1, str1: 1」
    cout << *p0 << ": " << p0.use_count() << ", " << *p1 << ": " << p1.use_count() << endl;

    // 2. 拷贝构造函数, 引用计数 +1
    auto p2(p0), p3 = p0;
    // 输出: 「str0: 3, str1: 1」
    cout << *p0 << ": " << p0.use_count() << ", " << *p1 << ": " << p1.use_count() << endl;

    // 3. 赋值运算符, 右边的引用计数 +1, 左边的原来指向的对象 -1
    //    若p2原来指向的对象引用计数为0了, 则清理原来对象的内存
    p2 = p1;
    // 输出: 「str0: 2, str1: 2」
    cout << *p0 << ": " << p0.use_count() << ", " << *p1 << ": " << p1.use_count() << endl;

    // 4. 退出程序后依次析构上述变量, p0、p1、p2、p3引用计数依次减1
    //    若引用计数归0, 在析构函数中清理内存
    return 0;
}