学习记录-std::shared_ptr

概述

std::shared_ptr<T>提供一种多个栈对象协作管理同一个堆对象的机制。以便在堆对象没有被引用的情况下将其free。
std::shared_ptr<T>的重要字段：

_Ty *_Ptr;                    //被管理的动态内存指针
_Ref_count_base *_Rep;        //计数器基类指针，用于指示有几个shared_ptr共享_Ptr指向的对象

shared_ptr是一种智能指针（smart pointer），作用有如同指针，但会记录有多少个shared_ptrs共同指向一个对象。这便是所谓的引用计数（reference counting）。
一旦最后一个这样的指针被销毁，也就是一旦某个对象的引用计数变为0，这个对象会被自动删除。

创建

有三种方式，分别为构造函数、std::make_shared<T>辅助函数和reset方法

1. 构造函数

就像普通的类一样，需要在定义变量的时候，使用new 对象作为输入参数。但是这种方法需要两次申请内存空间，第一次是new，第二是智能对象本身需要申请的内存。

2. std::make_shared<T>辅助函数

因为是在下的一个模板函数，实现了同时申请内存，推荐使用。例如

auto p = std::make_shared<Person>(“Chris”);

表示创建了智能指针对象，对Person对象进行管理，该Person对象的构造函数的输入参数为字符串"Chris"。此时，可以使用auto自动推导。

3. reset

就是让智能指针对象重新指向一个新的对象，而对原来所指对象的计数减1。

在进行reset(new xxx())重新赋值时，智能指针对象首先是生成新的对象，然后将指针对象的引用计数减1（当然，若方法计数为0，则析构），然后将新对象的指针交给智能指针保管。

例如：

std::shared_ptr p1(new Person(1));// Person(1)的引用计数为1
p1.reset(new Person(3)); // 此时，p1先进行new Person(3)，
// 然后p1会对Persion(1)的引用计数减1。此处为0，就会析构Person(1)。最后管理新的对象Person(3)

获取原始指针

std::shared_ptr<int> p(new int(5));

int *pInt = p.get()

指定删除器

默认删除器不支持数组对象，所以需要指定删除器。

注意事项

• 原始指针只能初始化一个shared_ptr；
• 在函数实参中不创建shared_ptr;
• 禁止通过shared_from_this()返回this，这样做可能造成二次析构；
• 避免循环引用（智能指针最大的一个陷阱是循环引用）

解决方法是使用weak_ptr；就是在相互调用的类中使用std::weak_ptr wpa和std::weak_ptr wpb，而不使用std::shared_ptr和std::shared，

总结

(1) 智能指针主要的用途就是方便资源的管理，自动释放没有指针引用的资源。

(2) 使用引用计数来标识是否有多余指针指向该资源。(注意，shart_ptr本身指针会占1个引用)

(3) 在赋值操作中, 原来资源的引用计数会减一，新指向的资源引用计数会加一。

• std::shared_ptr p1(new Test);

• std::shared_ptr p2(new Test);

• p1 = p2;

(4) 引用计数加一/减一操作是原子性的，所以线程安全的。

(5) make_shared要优于使用new，make_shared可以一次将需要内存分配好。

• std::shared_ptr p = std::make_shared();
• std::shared_ptr p(new Test);

(6) std::shared_ptr的大小是原始指针的两倍，因为它的内部有一个原始指针指向资源，同时有个指针指向引用计数。

(7) 引用计数是分配在动态分配的，std::shared_ptr支持拷贝，新的指针获可以获取前引用计数个数。

std::weak_ptr用法

std::weak_ptr并不是一种独立的智能指针，而是std::shared_ptr的一种扩充。
std::weak_ptr一般是由std::shared_ptr创建的，之后两者就指涉到相同的控制块，但std::weak_ptr并不会影响所指涉对象的引用计数。

std::weak_ptr使用场景

1. 带缓存功能的工厂函数
为什么要加缓存？
当调用工厂函数成本高昂（以为其执行了文件或数据库的I/O操作），且ID会被频繁的重复使用的话，则就需要加一级缓存来优化。
为什么要用std::weak_ptr
首先，由调用者去决定这些对象（工厂函数返回的对象）的生存周期（std::shared_ptr做不到），然而函数内存的缓存管理器也需要一个指涉到这些对象的指针（std::shared_ptr做不到），并且缓存管理器的指针需要校验他们何时会悬空（裸指针做不到）。
示例：

#ifndef WEAKPTRDEMO_H
#define WEAKPTRDEMO_H

#include <iostream>
#include <unordered_map>
#include <memory>

namespace T18_NS {

using namespace std;

/*!
 * \brief The Investment class 基类
 */
class Investment
{
public:
    virtual ~Investment() = default;

public:
    virtual void doWork() = 0;
};

/*!
 * \brief The Stock class 派生类
 */
class Stock : public Investment
{
public:
    ~Stock() {
        cout << "~Stock() called....\n";
    }
public:
    virtual void doWork() override {
        cout << "Stock doWork....\n";
    }
};

/*!
 * \brief The Stock class 派生类
 */
class Bond : public Investment
{
public:
    ~Bond() {
        cout << "~Bond() called....\n";
    }

public:
    virtual void doWork() override {
        cout << "Bond doWork....\n";
    }
};

enum class InvestType {
    INVEST_TYPE_STOCK,
    INVEST_TYPE_BOND,
};

// 工厂函数
auto makeInvestment(InvestType type)
{
    // 自定义析构器, 这里以lambda表达式的形式给出
    auto delInvmt = [](Investment *pInvestment) {
        cout << "custom delInvmt called...." << pInvestment << endl;

        // 注意：pInvestment可能为空指针，比如默认为空，然后调用reset赋值时，会先调用一遍析构
        if (pInvestment)
        {
            // TODO 自定义析构时想干的事
            delete pInvestment;
        }
    };

    // 待返回的指针, 初始化为空指针
    shared_ptr<Investment> pInv(nullptr);

    // 注意这里用reset来指定pInv获取从new产生的对象的所有权, 不能用=赋值
    switch (type)
    {
    case InvestType::INVEST_TYPE_STOCK:
        // 注意：自定义析构器是随对象一起指定的，这里区别于unique_ptr
        pInv.reset(new Stock, delInvmt);
        break;
    case InvestType::INVEST_TYPE_BOND:
        // 如果不指定自定义析构器的话，则不会调用
        pInv.reset(new Bond);
        break;
    }

    // 返回智能指针
    return pInv;
}

// 带缓存的工厂函数
// 使用场景：当调用工厂函数makeInvestment成本高昂(e.g. 会执行一些文件或数据块的I/O操作), 
// 并且type会频繁的重复调用
shared_ptr<Investment> fastLoadInvestment(InvestType type)
{
    // 定义一个做缓存的容器，注意这里存的内容是weak_ptr
    // 使用weak_ptr的好处是，它不会影响所指涉对象的引用计数
    // 如果这里改为shared_ptr的话，则函数外边永远不会析构掉这个对象, 因为缓存中至少保证其引用计数为1。
    //这就背离的我们的设计
    static unordered_map<InvestType, weak_ptr<Investment>> s_cache;

    // 将weak_ptr生成shared_ptr
    auto pInv = s_cache[type].lock();

    // 如果缓存中没有的话，则调用工厂函数创建一个新对象，并且加入到缓存中去
    if (!pInv)
    {
        cout << "create new investment..\n";
        pInv = makeInvestment(type);
        s_cache[type] = pInv;
    }

    return pInv;
}

void test()
{
    {
        auto pInv = fastLoadInvestment(InvestType::INVEST_TYPE_BOND);
        pInv->doWork();
    }

    cout << "-------------------------------\n";

    {
        auto pInv = fastLoadInvestment(InvestType::INVEST_TYPE_BOND);
        pInv->doWork();
    }

    cout << "-------------------------------\n";

    {
        auto pInv = fastLoadInvestment(InvestType::INVEST_TYPE_STOCK);
        pInv->doWork();
        auto pInv2 = fastLoadInvestment(InvestType::INVEST_TYPE_STOCK);
        pInv2->doWork();
    }

}



} // T18_NS

#endif // WEAKPTRDEMO_H

2. 观察者设计模式

该模式的主要组件是主题和观察者，在多数实现中，每个主题包含一个数据成员，该成员持有指涉到观察者的指针，这才能使得主题能够很容易的在其发生状态改变时发出通知。主题不会控制其观察者的生存期（即不关心它们何时析构），但是需要确认当一个观察者被析构之后，主题不会去访问它。一个合理的设计就是让每个主题只有一个容器来放置指涉到其观察者的std::weak_ptr，以便主题在使用某个指针之前，能够先确定它是否空悬。

3. 用来打破std::shared_ptr引起的环路