智能指针 shared_ptr weak_ptr shared_from_this 笔记

shared_ptr

当指向对象的std::shared_ptr一创建，被管理对象的控制块SharedPtrControlBlock（参考下面的图）就建立了。

被管理的对象的控制块中有引用计数(reference count)，当引用计数为0时，被管理的对象会被销毁。

控制块的创建会遵循下面几条规则：

std::make_shared会创建控制块

从 std::unique_ptr 上构造出 std::shared_ptr的时候，会创建控制块

从原始指针上构造 std::shared_ptr的时候会创建控制块

假若我们为一个指针构建了多个控制块，那么会有多个引用计数，意味着对象可能销毁多次，这是非法行为

多次从原始指针上构建智能指针，实际存在多个互不相干的引用计数，大家都为1，然后一旦有一个智能指针不再指向该对象，引用为0就会析构对象，就会出错

定义智能指针的方式

std::shared_ptr<A> p1(new A);
std::shared_ptr<A> p2 = std::make_shared<A>();

在执行std::shared_ptrp1(new A) 的时候，首先会申请数据的内存，然后申请内控制块，因此是两次内存申请

而std::make_shared()则是只执行一次内存申请，将数据和控制块的申请放到一起

shared_ptr指针的内存结构图，做个参考，可能不完全对

每个shared_ptr都占指针的两倍空间，一个装着原始指针，一个装着计数区域(SharedPtrControlBlock)的指针

用原始指针构造时，会new一个SharedPtrControlBlock出来作为计数存放的地方，然后用指针指向它，计数加减都通过SharedPtrControlBlock指针间接操作

这其中包含两个Count变量，weak count是用于weak_ptr的弱引用计数（weak_ptr要用shared_ptr初始化，使用同一块控制块？）

图片来自

std::enable_shared_from_this 有什么意义？ - 孔洽孔洽的回答 - 知乎https://www.zhihu.com/question/30957800/answer/2700292012

weak_ptr

还记得，shared_ptr内含有指向计数区域(SharedPtrControlBlock)结构体的指针吧

struct SharedPtrControlBlock{
　　int shared_count;
　　int weak_count;
};

该结构体引进新的int变量weak_count，来作为弱引用计数

每个weak_ptr都占指针的两倍空间，一个装着原始指针，一个装着计数区域的指针（和shared_ptr一样的成员）

大概是这样
class weak_ptr{
　　T* ptr;
　　SharedPtrControlBlock* count;
};

被管理资源的释放只取决于shared计数，当shared计数为0，才会释放被管理资源，

但是控制块计数区域的释放却取决于shared计数和weak计数，当两者均为0时，才会释放计数区域

这也就是weak_ptr能够使用expired方法判断对象是否被析构的原因，因为该计数区域还在

weak_ptr 一般者是通过 shared _ptr 或另一个weak_ptr 来初始化

weak_ptr不会改变资源的引用计数，只是一个观察者的角色，通过观察shared_ptr来判定资源是否存在，不会影响指向对象（被管理资源）的生命周期，而shared_ptr引用计数为0则会析构对象

weak_ptr持有的引用计数，不是资源的引用计数，而是同一个资源的观察者的计数

weak_ptr没有提供常用的指针操作，无法直接访问资源，需要先通过lock方法提升为shared_ptr强智能指针，才能访问资源

成员函数use_count() 观测资源引用计数

成员函数expired() 功能相当于 use_count()为 0 表示被观测的资源(也就是shared_ptr的管理的资源)被销毁

成员函数lock()从被观测的shared_ptr获得一个可用的shared_ptr对象， 进而操作资源。但当expired()==true的时候，lock()函数将返回一个存储空指针的shared_ptr

来自csdn

原文链接：https://blog.csdn.net/qq_53111905/article/details/122240842

循环引用问题

看下面一段代码

weak_ptr用于解决两个类内部使用shared_ptr互相引用造成的循环，TestA和TestB中weak_ptr如果换成是shared_ptr

那么在离开main函数时，两个在main中创建的shared_ptr失效，本来引用数都是2，各自减一都变为了1，也就是内部的shared_ptr互相指向，成为一个环

两个对象都还被引用着，所以不会析构，造成内存泄露

所以将shared_ptr都改为weak_ptr，离开main时两个在main中创建的shared_ptr都会失效，各自的引用减一，变为0，内部的弱指针不影响引用计数，故而能够正确释放内存

//示例代码1.0 http://www.cnblogs.com/feng-sc/p/5710724.html
#include <memory>
class TestB;
class TestA
{
public:
    TestA()
    {
        std::cout << "TestA()" << std::endl;
    }
    void ReferTestB(std::shared_ptr<TestB> test_ptr)
    {
        m_TestB_Ptr = test_ptr;
    }
    void TestWork()
    {
        std::cout << "~TestA::TestWork()" << std::endl;
    }
    ~TestA()
    {
        std::cout << "~TestA()" << std::endl;
    }
private:
    std::weak_ptr<TestB> m_TestB_Ptr;
};

class TestB
{
public:
    TestB()
    {
        std::cout << "TestB()" << std::endl;
    }

    void ReferTestB(std::shared_ptr<TestA> test_ptr)
    {
        m_TestA_Ptr = test_ptr;
    }
    void TestWork()
    {
        std::cout << "~TestB::TestWork()" << std::endl;
    }
    ~TestB()
    {
        std::shared_ptr<TestA> tmp = m_TestA_Ptr.lock();
        tmp->TestWork();
        std::cout << "2 ref a:" << tmp.use_count() << std::endl;
        std::cout << "~TestB()" << std::endl;
    }
    std::weak_ptr<TestA> m_TestA_Ptr;
};

int main()
{
    std::shared_ptr<TestA> ptr_a = std::make_shared<TestA>();
    std::shared_ptr<TestB> ptr_b = std::make_shared<TestB>();
    ptr_a->ReferTestB(ptr_b);
    ptr_b->ReferTestB(ptr_a);
    std::cout << "1 ref a:" << ptr_a.use_count() << std::endl;
    std::cout << "1 ref b:" << ptr_a.use_count() << std::endl;
    return 0;
}

shared_from_this要解决的问题

需求: 在类的内部需要自身的shared_ptr 而不是this裸指针，直接从this指针创建？那会导致出现多个引用计数器，会错误析构，因为每调用一次就创建一个指针

场景: 在类中发起一个异步操作, callback回来要保证发起操作的对象仍然有效，std::bind函数和对象，结果对象先被析构了，那还调用个屁

异步回调的时候对象可能已经被销毁了 所以使用shared_ptr 传出去就是保证最少还有一个引用计数维持对象的生命周期直到回调结束

struct A {
  void func() {
      std::shared_ptr<A> local_sp_a(this);
      // do something with local_sp_a
  }
};

上面这段代码，由成员函数直接在this上构建智能指针，当离开该函数作用域，local_sp_a就会失效，则引用计数少1，则会立即析构this

改成这样

struct A : public enable_shared_from_this {
  void func() {
    std::shared_ptr<A> local_sp_a = shared_from_this();
    // do something with local_sp
  }
};

shared_from_this()会查找当前对象控制块，然后创建一个新的std::shared_ptr关联这个控制块。

用这个函数之前，是假设当前对象已经存在一个关联的控制块。因此，必须已经存在一个指向当前对象的std::shared_ptr。

如果没有std::shared_ptr指向当前对象（即当前对象没有关联控制块），那么shared_from_this会抛出一个异常。

智能指针出现的意义

智能指针的应用场景其实大概就了解了，

有时，程序不能正常释放内存资源，忘记释放就不说了，如出现异常，后面的代码不会执行，可能析构对象的代码就被忽略了

有时候，对象已经不存在了，被析构了，然而程序仍在调用该对象的成员函数，则会出错，可以通过weak_ptr判断对象是否还在

异步，以及多线程的情况下，都会出现对象可能不存在了的情况

可以通过weak_ptr的lock方法判断是否为nullptr来判断对象是否被析构

智能指针使用总结

当你需要一个独占资源所有权（访问权+生命控制权）的指针，且不允许任何外界访问，使用std::unique_ptr

当你需要一个共享资源所有权（访问权+生命控制权）的指针，使用std::shared_ptr

当你需要一个能访问资源，但不控制其生命周期的指针，使用std::weak_ptr

一个shared_ptr和n个weak_ptr搭配使用而不是n个shared_ptr

因为一般模型中，最好总是被一个指针控制生命周期，然后可以被n个指针控制访问

参考链接：https://www.cnblogs.com/KillerAery/p/9096558.html