智能指针shared_ptr

// 智能指针会自动释放所指向的对象。
// shared_ptr的应用场景是：程序需要在多个对象间共享数据

/* 先从应用场景入手吧，说矿工A发现了一个金矿。
 * 然后矿工A喊来了矿工B，一起开采，不久后矿工A劳累过度死了。
 * 矿工B继续开采着矿工A发现的金矿。
 * 但是矿工B不久后得了尘肺病。
 * 这时候如果矿工B喊来了矿工C，那矿工C就继续开采这个金矿，
 * 如果矿工B至死都没有喊anyone，那么这个金矿不再被任何人发现。
 *
 * 我们来说说实现
 * 每个矿工new一个对象，金矿new一个对象。
 * 矿工死了就delte掉，金矿不再被发现也delte掉。
 *
 * 但是我们有没有可能让最后一个矿工死时，金矿被自动delte掉？
 * 这样的话我们就不需要额外管理金矿对象了。
 * 有可能啊，你用共享指针啊。
 * 共享指针管理一个对象，管理一个引用计数。
 * 每次对共享指针赋值和拷贝时，引用计数就加1。
 * 当共享指针被销毁时，引用计数就减1。
 * 这样就变成多个矿工间共享金矿数据了。
 *
 * 下面我们来说说引用计数递增的情况
 * 1 用一个shared_ptr初始化另一个shared_ptr，肯定调用拷贝构造函数喽
 * 2 用一个shared_ptr赋值另一个shared_ptr，肯定调用赋值函数喽
 * 3 将shared_ptr作为参数传递给一个函数，这个也会调用拷贝构造函数
 * 4 将shared_ptr作为函数的返回值，这个也会调用拷贝构造函数
 *
 * 下面我们来说说引用计数递减的情况
 * 1 shared_ptr被销毁，参数出栈是被销毁的一种情况
 * 2 给shared_ptr重新赋值
 *
 * 一旦一个shared_ptr的引用计数变为0，它就会自动释放所管理的对象。
 */

#include <iostream>
#include <memory>

using namespace std;

struct Gold
{
    ~Gold() {total = -1;}
    int total{20};

    Gold &operator--()
    {
        --total;
        return *this;
    }

    const Gold operator--(int)
    {
        Gold tmp = *this;
        --(*this);
        return  Gold(tmp);
    }
};

class Miner
{
public:
    Miner() : gold(make_shared<Gold>()) {}

    Miner(const Miner &miner)
    {
        gold = miner.gold;
    }

    void dig()
    {
        (*gold)--;
    }

    Gold *base()
    {
        return gold.get();
    }

private:
    shared_ptr<Gold> gold;
};

int main(int argc, char *argv[])
{
    auto miner1 = new Miner;
    auto miner2 = new Miner(*miner1);

    // 代码执行到这里
    // @表示地址 usecount是引用计数
    // miner1的gold @0x605f40
    // miner2的gold @0x605f40
    // shared_ptr的usecount是2
    // 可见miner1和miner2的gold指向同一个对象
    // 引用计数正确

    auto gold = miner2->base();

    // 代码执行到这里
    // gold @0x605f40

    miner1->dig();
    cout << gold->total << endl;
    miner2->dig();
    cout << gold->total << endl;
    miner1->dig();
    cout << gold->total << endl;

    delete miner1;

    // 代码执行到这里
    // miner1的gold (null)
    // miner2的gold @0x605f40
    // shared_ptr的usecount是1
    // 引用计数正确

    miner2->dig();
    cout << gold->total << endl;

    delete miner2;

    // 代码执行到这里
    // miner1的gold (null)
    // miner2的gold @0x605f20
    // miner2管理的对象(@0x605f40) 已被销毁
    // 调用了Gold的析构函数
    // gold->totle值为-1
    // 至于miner2的gold @0x605f20 ？？
    // 管它呢，反正已引用不到

    cout << gold->total << endl;

    int *p2;
    {
        auto p1 = make_shared<int>(5);
        p2 = p1.get();

        // 代码执行到这里
        // p1 @0x605f60
        // usecount是1
        // p2 指向@0x605f60
    }

    // 代码执行到这里
    // 代码块出栈了，p1被销毁
    // usecount变为0，所以p1管理的对象也被销毁了
    // ***这是为什么不建议用get的原因
    // 虽然可以正确输出p2所指向的对象，但是这是不确定的
    // p2就是所谓的野指针了
    cout << *p2 << endl;

    shared_ptr<int> p4;
    {
        auto p3 = make_shared<int>(5);
        p4 = p3;

        // 代码执行到这里
        // p3 @0x605f60
        // p4 @0x605f60
        // usecount是2
    }

    // 代码执行到这里
    // 代码块出栈了，p3被销毁
    // usecount变为1，p3并未销毁所管理的对象
    // p4所管理的对象可以正确输出
    cout << *p4 << endl;

    return 0;
}