智能指针1

引用计数是智能指针的一种通用实现技术，基本原理如下：

1. 在每次创建类的新对象时，初始化指针并将引用计数置 1；
2. 当对象作为另一对象的副本而创建时（复制构造函数），复制对应的指针并将引用计数 +1；
3. 当对一个对象进行赋值时，赋值操作符 = 将左操作数所指对象的引用计数 -1，将右操作数所指对象的引用计数 +1；
4. 调用析构函数数，引用计数 -1；
5. 上述操作中，引用计数减至 0 时，删除基础对象；

STL 库中的智能指针 shared_ptr 和 TARS 智能指针都使用了该引用计数原理，后面会进行介绍。

STL 库的智能指针
C++ 标准模板库 STL 中提供了四种指针 auto_ptr, unique_ptr, shared_ptr, weak_ptr。

auto_ptr 在 C++98 中提出，但其不能共享对象、不能管理数组指针，也不能放在容器中。因此在 C++11 中被摒弃，并提出 unique_ptr 来替代，支持管理数组指针，但不能共享对象。

shared_ptr 和 weak_ptr 则是 C++11 从标准库 Boost 中引入的两种智能指针。shared_ptr 用于解决多个指针共享一个对象的问题，但存在循环引用的问题，引入 weak_ptr 主要用于解决循环引用的问题。

接下来将详细介绍 shared_ptr

shared_ptr
shared_ptr 解决了在多个指针间共享对象所有权的问题，最初实现于 Boost 库中，后来收录于 C++11 中，成为了标准的一部分。shared_ptr 的用法如下
————————————————
版权声明：本文为CSDN博主「TARS基金会」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/TARSFoundation/article/details/109456189

简单介绍智能指针  shared_ptr 的用法。

#include <memory>
#include <iostream>
using namespace std;

class A {
public:
    A() {};
    ~A() {
        cout << "A is destroyed " << endl;
    }
};

class B {
public:
    B() {
        cout << "B is construct" << endl;
    };
    B(int b) {
        cout << "B2 is construct" << endl;
    }
    ~B() {
        cout << "B is destroyed " << endl;
    }
};


int main()
{
    //shared_ptr 引用技术打印
    std::shared_ptr<A> sptrA(new A);
    cout <<"sptrA count:"<< sptrA.use_count() << endl;
    {
        std::shared_ptr<A> cp_sptrA = sptrA;
        cout << "sptrA count:" << sptrA.use_count() << endl;
    }
    cout << "sptrA count:" << sptrA.use_count() << endl;


    //使用 make_shared 创建 shared_ptr对象
    std::shared_ptr<B> sptrB1 = std::make_shared<B>();
    std::shared_ptr<B> sptrB2 = std::make_shared<B>(2);

    system("pause");
    return 0;
}

make_shared 用法，请参考其他相关文章。

https://www.cnblogs.com/zzm1/p/14077662.html

shared_ptr 循环引用问题举例：

#include <memory>
#include <iostream>
using namespace std;

class B;
class A
{
public:
    A() : m_sptrB(nullptr) {};
    ~A()
    {
        //循环引用，导致析构函数无法执行，内存不能释放
        cout << " A is destroyed" << endl;
    }
    shared_ptr<B> m_sptrB;
};

class B
{
public:
    B() : m_sptrA(nullptr) {};
    ~B()
    {
        //循环引用，导致析构函数无法执行，内存不能释放
        cout << " B is destroyed" << endl;
    }
    shared_ptr<A> m_sptrA;
};

int main()
{
    {
        shared_ptr<B> sptrB(new B);//sptrB对应的引用计数置为1
        shared_ptr<A> sptrA(new A);//sptrA对应的引用计数置为1
        sptrB->m_sptrA = sptrA;//sptrA对应的引用计数变成2，sptrB仍然是1
        sptrA->m_sptrB = sptrB;//sptrB对应的引用计数变成2，sptrA是2
    }
    //退出main函数后，sptrA和sptrB对应的引用计数都-1，变成1，
    //此时A和B的析构函数都不能执行（引用计数为0才能执行），无法释放内存
    return 0;
}