C++智能指针shared_ptr用法

写在前面的总结：
一个shared_ptr对象管理一个指针（new T，在堆空间），多个shared_ptr对象可以管理同一个指针，只有某个shared_ptr对象第一次初始化指针时才执行指针的构造函数，管理同一个指针的shared_ptr对象个数称为引用计数，这个引用计数保存在每个管理该指针的shared_ptr对象中，当引用计数为0时，这个指针执行析构函数释放；shared_ptr对象也可以管理空指针，此时引用计数为0。
shared_ptr做为函数参数传递时，函数运行期间引用计数加一，函数运行完后离开作用域，引用计数减一。

shared_ptr功能介绍

智能指针和普通指针用法相似，智能指针的本质是一个模板类，对普通指针进行了封装，通过在构造函数中初始化分配内存，在析构函数中释放内存，达到自己管理内存，不需要手动管理内存的效果，避免了忘记释放内存而导致的内存泄露。

shared_ptr 是C++11提供的一种智能指针类，可以在任何地方都不使用时自动删除相关指针，从而帮助彻底消除内存泄漏和悬空指针的问题。
它遵循共享所有权的概念，即不同的 shared_ptr 对象可以与相同的指针相关联，并在内部使用引用计数机制来实现这一点。
每个 shared_ptr 对象在内部指向两个内存位置：
1、指向对象的指针。
2、用于控制引用计数数据的指针。
共享所有权如何在参考计数的帮助下工作：
1、当新的 shared_ptr 对象与指针关联时，则在其构造函数中，将与此指针关联的引用计数增加1。
2、当任何 shared_ptr 对象超出作用域时，则在其析构函数中，它将关联指针的引用计数减1。如果引用计数变为0，则表示没有其他 shared_ptr 对象与此内存关联，在这种情况下，它使用delete函数删除该内存。

shared_ptr是以类模板的方式实现的，shared_ptr（其中 T 表示指针指向的具体数据类型）的定义位于头文件。

shared_ptr提供的接口

shared_ptr是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
shared_ptr的存储指针和引用计数指针是一一对应的，即shared_ptr里存的是存储指针，对应的引用计数指针就是对stored pointer的加一，因此shared_ptr在其内部，给每个资源都维护着一份计数，用来记录该份资源被几个对象共享。

shared_ptr初始化

构造函数初始化

///1.构造函数初始化
//传入空指针或什么都不传，构造出空智能指针，其初始引用计数方式为0
std::shared_ptr<int>  p0(nullptr);
printf("p0.use_count=%ld\n",p0.use_count());//p0.use_count=0

//构造函数初始化，指向一个存有5这个int类型数据的堆内存空间
std::shared_ptr<int> p1(new int(5));
printf("p1=%p\n",&p1);//p1=0x7ffc24046f10
printf("p1=%d\n",*p1);//p1=5
printf("p1.use_count=%ld\n",p1.use_count());//1

std::shared_ptr<int> p2(p1);//p1和p2都指向那个存有int型5的堆内存空间，堆内存的引用次数会加1
printf("p1.use_count=%ld\n",p1.use_count());//2
printf("p2.use_count=%ld\n",p2.use_count());//2

std::shared_ptr<int> p3=p0;//P0为空，则P3也为空，其引用计数依然为0
printf("p3.use_count=%ld\n",p3.use_count());//0

//补充
//可以把原始指针传参构造shared_ptr对象，此时原始指针没有new或没有初始化赋值，use_count都是1
int *p11 = new int;//如果没有=new int，下面p12.use_count还是1，但执行打印时会crash
//p11 = nullptr;//如果p11赋值为nullptr，下面p12.use_count还是1，但执行打印时会crash
std::shared_ptr<int> p12(p11);
printf("p12.use_count=%ld\n",p12.use_count());//1
printf("*p12=%d\n",*p12);//*p12=1345903632（原始指针new了，但没有初始化，则打印未知值）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

std::make_shared 初始化

///2.std::make_shared 初始化
std::shared_ptr<int> p4 = std::make_shared<int>(); //1.定义一个空的智能指针
std::shared_ptr<int> p5= std::make_shared<int>(10);//2.创建指针，并明确指向
auto p6 = std::make_shared<std::vector<int>>();//3.auto关键字代替std::shared_ptr，p8指向一个动态分配的空vector
1
2
3
4

reset初始化

///3.reset初始化
//调用reset（new xxx())重新赋值时，智能指针首先是生成新对象，然后将旧对象的引用计数减1（当然，如果发现引用计数为0时，则析构旧对象），然后将新对象的指针交给智能指针保管。
std::shared_ptr<int> p7(new int(20));
std::shared_ptr<int> p8(p7);
std::shared_ptr<int> p9(p7);
printf("p9.use_count=%ld\n",p8.use_count());//3
p7.reset(new int(21));//当为reset传递一个新申请的堆内存时，则调用该函数的 shared_ptr 对象会获得该存储空间的所有权，并且引用计数的初始值为1;其所指向的原堆内存引用计数减1
printf("p9.use_count=%ld\n",p8.use_count());//2
p9.reset();//当reset没有实参时，该函数会使当前 shared_ptr 所指堆内存的引用计数减 1，同时将当前对象重置为一个空指针
if(p9 == nullptr)
    printf("p10 == nullptr\n");//p10 == nullptr
printf("p9.use_count=%ld\n",p8.use_count());//1
1
2
3
4
5
6
7
8
9
10
11
12

shared_ptr管理指针的构造和析构

下面例子介绍shared_ptr是如何管理所指向指针（堆空间）的构造和析构的。

class book
{
public:
    book(int v) {//构造函数
        value = v;
        std::cout << "cons book value=" <<value<< std::endl;
    }
    ~book() {//析构函数
        std::cout << "desc book value=" <<value<< std::endl;
    }
    int value;
};

{
    std::shared_ptr<book> b1(new book(100));//cons book value=100
    std::shared_ptr<book> b2(b1);//只增加了引用计数，没有新增构造book，use_count=2
    b2.reset(new book(200));//cons book value=200（新构造book200，原book100计数变为1）
    b1.reset(new book(300));//cons book value=300   desc book value=100（新构造book300，原book100引用计数变为0，执行析构）

    printf("end\n");//准备离开作用域
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

打印，shared_ptr初始化时如果生成了新的指针，则执行指针的构造函数，如果指向该指针的shared_ptr对象引用计数为0时，执行该指针的析构函数；
如果shared_ptr对象超出了作用域，则引用计数减1，引用计数为0时执行析构。

cons book value=100
cons book value=200
cons book value=300
desc book value=100
end
desc book value=200
desc book value=300
1
2
3
4
5
6
7

shared_ptr获取原始指针

智能指针提供了get()成员函数，用来执行显示转换，返回智能指针内部的原始指针。

std::shared_ptr<int> p10(new int(300));
int *pn = p10.get();
printf("pn=%d\n",*pn);//pn=300
1
2
3

shared_ptr的线程安全

1、shared_ptr不是线程安全的；
2、在多线程下，不能保证new出来一个对象一定能被放入shared_ptr中，也不能保证智能指针管理的引用计数的正确性；
3、同一个shared_ptr对象可以被多线程同时读取，不同的shared_ptr对象可以被多线程同时修改，但同一个shared_ptr对象不能被多线程直接修改；
4、在创建一个shared_ptr时，需要使用C++11提供的make_shared模板，make_shared创建shared_ptr只申请一次内存，避免了上述错误，也提高了性能，同时在读写操作时，需要加锁。

shared_ptr应用之enable_shared_from_this

C++11 开始支持 enable_shared_from_this，它是一个模板类，定义在头文件 ，其原型为：

template< class T > class enable_shared_from_this;
1

enable_shared_from_this 能让一个指针（假设其名为 t ，且已被一个 std::shared_ptr 对象 pt 管理）安全地生成其他额外的 std::shared_ptr 实例（假设名为 pt1, pt2, … ） ，它们与 pt 共享对象 t 的所有权。
若一个类 T 继承 std::enable_shared_from_this ，则会为该类 T 提供成员函数： shared_from_this 。
当 T 类型对象 t 被一个为名为 pt 的 std::shared_ptr 类对象管理时，调用 T::shared_from_this 成员函数，将会返回一个新的 std::shared_ptr 对象，它与 pt 共享 t 的所有权。

使用场景
1、当类A被share_ptr管理，且在类A的成员函数里需要把当前类对象作为参数传给其他函数时，就需要传递一个指向自身的share_ptr。
2、在异步调用中，可能会使用到之前存在的变量，为了保证该变量在异步调用中一直有效，可以传递一个指向自身的share_ptr给异步函数，这样share_ptr所管理的对象就不会析构（引用计数至少>=1，保活）。

#include 
class Good : public std::enable_shared_from_this<Good> // 注意：继承
{
public:
    Good(){std::cout << "Good::Good() called" << std::endl; }
    std::shared_ptr<Good> getptr() {
        return shared_from_this();
    }
    ~Good() { std::cout << "Good::~Good() called" << std::endl; }
};
MainWindow::MainWindow(QWidget *parent)    : QMainWindow(parent)    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    std::shared_ptr<Good> gp1(new Good());
    std::cout << "gp1.use_count() = " << gp1.use_count() << std::endl;//1
    std::shared_ptr<Good> gp2 = gp1->getptr();
    std::cout << "gp1.use_count() = " << gp1.use_count() << std::endl;//2
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

打印

Good::Good() called
gp1.use_count() = 1
gp1.use_count() = 2
Good::~Good() called
1
2
3
4

weak_ptr

std::weak_ptr 是一种智能指针，通常不单独使用，只能和 shared_ptr 类型指针搭配使用，可以视为 shared_ptr 指针的一种辅助工具。借助 weak_ptr 类型指针可以获取 shared_ptr 指针的一些状态信息，比如有多少指向相同的 shared_ptr 指针、通过expired()判断shared_ptr 指针指向的堆内存是否已经被释放等等，还可以解决shared_ptr 循环引用的问题。

weak_ptr可以从一个shared_ptr或者另一个weak_ptr对象构造，获得资源的观测权。但weak_ptr没有共享资源，它的构造不会引起指针引用计数的增加。使用weak_ptr的成员函数use_count()可以观测资源的引用计数，另一个成员函数expired()的功能等价于use_count()==0，但更快。表示被观测的资源(也就是shared_ptr的管理的资源)已经不复存在。

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

        std::shared_ptr<int> sh_ptr = std::make_shared<int>(10);//创建一个智能指针
        printf("sh_ptr.use_count()=%ld\n",sh_ptr.use_count());//sh_ptr.use_count()=1

        std::weak_ptr<int> wp(sh_ptr);//构造 weak_ptr，不会增加智能指针的引用计数
        printf("sh_ptr.use_count()=%ld\n",sh_ptr.use_count());//sh_ptr.use_count()=1
        printf("wp.use_count() =%ld\n",wp.use_count() );// wp.use_count() =1

        if(!wp.expired())
        { // 检查sh_ptr是否还有效
            std::shared_ptr<int> sh_ptr2 = wp.lock(); //使用 weak_ptr 构造一个智能指针，引用计数+1
            *sh_ptr = 100;
            printf("wp.use_count() =%ld\n",wp.use_count() );// wp.use_count() =2
        }
    } //delete memory

    std::weak_ptr<int> wp;
    {
        std::shared_ptr<int> sh_ptr = std::make_shared<int>(10);
        wp = sh_ptr;//构造 weak_ptr
        printf("wp.expired()=%d\n",wp.expired());// wp.expired()=0，引用对象还没删除
    } //delete memory

    printf("wp.expired()=%d\n",wp.expired()); // wp.expired()=1，引用对象已经删除
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

sh_ptr.use_count()=1
sh_ptr.use_count()=1
wp.use_count() =1
wp.use_count() =2
wp.expired()=0
wp.expired()=1

循环引用问题
weak_ptr的一个作用是解决share_ptr的循环引用问题。如下面代码所示，class AA中含有指向class BB的shared指针, class BB 中含有指向class AA的shared指针，这样形成了循环引用。m_bb_ptr和m_aa_ptr的强引用计数永远大于等于1

class BB;

class AA
{
public:
    AA() { printf("AA::AA() called\n"); }
    ~AA() { printf( "AA::~AA() called\n"); }
    std::shared_ptr<BB> m_bb_ptr;//正确用法是使用weak_ptr，可以正常析构
};

class BB
{
 public:
    BB() { printf("BB::BB() called\n" ); }
    ~BB() { printf("BB::~BB() called\n" ); }
    std::shared_ptr<AA> m_aa_ptr;//正确用法是使用weak_ptr，可以正常析构
};

    std::shared_ptr<AA> ptr_a(new AA);
    std::shared_ptr<BB> ptr_b(new BB);
    printf( "ptr_a use_count: %ld\n" , ptr_a.use_count() );
    printf( "ptr_b use_count: %ld\n" , ptr_b.use_count() );
    //下面两句导致了AA与BB的循环引用，结果就是AA和BB对象都不会析构
    ptr_a->m_bb_ptr = ptr_b;
    ptr_b->m_aa_ptr = ptr_a;
    printf( "ptr_a use_count: %ld\n" ,ptr_a.use_count() );
    printf( "ptr_b use_count: %ld\n" ,ptr_b.use_count() );
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

AA::AA() called
BB::BB() called
ptr_a use_count: 1
ptr_b use_count: 1
ptr_a use_count: 2
ptr_b use_count: 2

智能指针shared_ptr开发注意事项

均为代码实测记录。

基本使用
1、std::shared_ptr p1调用reset后use_count减1，p1 == nullptr。
2、一个智能指针std::shared_ptr p1引用计数为0或者是空指针，则p1 == nullptr，不能调用类接口，但可以调用p1.use_count()，返回0。
3、不能使用delete释放std::shared_ptr的.get原始指针，程序会crash。
4、std::shared_ptr被push_back到std::vector数组，use_count加1，如果数组clear或智能指针成员被erase，use_count减1。

shared_from_this
1、类继承于std::enable_shared_from_this<>后，可以定义接口返回shared_from_this，这样函数就可以传递.get原始指针，在函数体内调用接口返回shared_from_this，在函数体内use_count加1。
2、如果使用shared_from_this().get()传参给void*，在函数执行过程中use_count加1，执行完成后use_count减1。
3、如果智能指针已释放，原始指针失效，此时通过原始指针调用接口返回shared_from_this时会抛出异常，可以捕获异常：try {pUdpSptr = pUdp->get_shared_ptr();} catch (std::exception &ex) {LogError ( " %s", ex.what()); }。

智能指针传参
1、std::shared_ptr可以通过.get获取原始指针，传参给void*类型，但引用计数不会增加。
2、std::shared_ptr p1做为普通参数传递，如果p1是空指针，则传递过程中use_count始终为0；如果p1不是空指针，执行过程中use_count加1，执行完成后use_count减1。
3、std::shared_ptr做为引用传递，如果p1是空指针，则传递过程中use_count始终为0；如果p1不是空指针，函数执行前后use_count也不会改变。
4、std::shared_ptr传参，如果要改变值，可以传shared_from_this，做为普通参数传递，执行过程中use_count加1，增加安全行，也可以改变原始指针的值。
5、lambda表达式传参智能指针，值传递会增加引用计数，引用传递不会增加引用计数；值传递，lambda表达生成的匿名函数func=nullptr后，引用计数减一。

智能指针做为返回值
1、std::shared_ptr做为普通返回值，use_count加1，但是如果没用定义std::shared_ptr变量接收返回值，use_count不变。
2、返回std::shared_ptr的引用，use_count和普通返回值一样；不能返回局部变量或临时变量的引用。
3、如果要返回空智能指针，可以return std::shared_ptr<>(nullptr)。

智能指针的构造和析构
1、新增std::shared_ptr变量时，如果生成了新的原始指针，则执行构造函数。
2、新增std::shared_ptr变量时，如果只增加了引用计数，没有生成新指针，则不会执行构造函数。
3、当引用计数变为0时，执行析构函数。
4、一句话，use_count从0变为1时执行构造，use_count从1变为0时执行析构。