C++智能指针

一、简介

由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，最终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。智能指针便可以有效缓解这类问题。
有四个模板智能指针类：auto_ptr, unique_ptr, shared_ptr, weak_ptr。
（一般优先使用unique，再shared）

image.png

二、std::auto_ptr，c++98的，c++11里已经弃用了。

因为它可能导致对同一块堆空间进行多次delete。
当两个智能指针都指向同一个堆空间时，每个智能指针都会delete一下这个堆空间，这会导致未定义行为。
针对这个问题有3种策略：
1、进行深度复制，有几个指针就复制几个对象；
2、制定指针专有权的概念。即，只有一个智能指针能真正指向一个特定的对象，也只有该指针能析构这个对象所占用的空间，直到把这个指针赋给另一个指针，后一个指针才能真正指向这个对象，而前一个指针就不再起作用了，从而避免了两次delete而导致的未定义行为。这个概念比较适合auto_ptr和unique_ptr，但后者要求更严格；
3、记录性智能指针。即，有一个智能指针指向某对象，就把这个对象上的智能指针数加1，有一个指针不再指向该对象，就把这个对象上的智能指针数减1。只有当最后一个智能指针生命期结束了，才真正释放对象空间。

三、unique_ptr 在头文件memory里

unique_ptr 实现独占式拥有或严格拥有概念，保证同一时间内只有一个智能指针可以指向该对象。它对于避免资源泄露(例如“以new创建对象后因为发生异常而忘记调用delete”)特别有用。
std::unique_ptr 是通过指针占有并管理另一对象，并在 unique_ptr 离开作用域时释放该对象的智能指针。
成员函数，常用的有make_unique,get

image.png

指针接管另外一个 a = move(b)

#include <iostream>
#include <memory>
using namespace std;
template<typename T>
struct Node
{
    T data;
    unique_ptr<Node<T>> next;
    ~Node() {
        cout << "~Node\n";
    }
};
template<typename T>
class list 
{
public:
    void front(const T& data) {
        auto node = make_unique<Node<T>>();
        node->data = data;
        node->next = move(head.next);   // 相当于 node.next = head.next;   切记一定要用move，不然会出错
        head.next = move(node);         // 相当于 head.next = node;        unique_ptr不能直接赋值
    }
    void print() {
        Node<T>* node = head.next.get();   //要用get方法获取到对象底层的指针，才能取出其中的数据
        // 直接取head.data取出的是未知数。。
        while (node) {
            cout << node->data << ' ';
            node = node->next.get();
        }
        cout << endl;
    }
private:
    Node<T> head;
};
int main() {
    list<int> l;
    for (int i : {1, 2, 3, 4, 5}) {
        l.front(i);
    }
    l.print();
}

四、shared_ptr 在头文件memory里

shared_ptr实现共享式拥有概念。多个智能指针可以指向相同对象，该对象和其相关资源会在“最后一个引用被销毁”时候释放。从名字share就可以看出了资源可以被多个指针共享，它使用计数机制来表明资源被几个指针共享。可以通过成员函数use_count()来查看资源的所有者个数。除了可以通过new来构造，还可以通过传入auto_ptr, unique_ptr,weak_ptr来构造。当我们调用release()时，当前指针会释放资源所有权，计数减一。当计数等于0时，资源会被释放。

shared_ptr 是为了解决 auto_ptr 在对象所有权上的局限性(auto_ptr 是独占的), 在使用引用计数的机制上提供了可以共享所有权的智能指针。
总的来说用法与unique相似，多了一个ues_count()，获取引用计数，有多少个共享指针共享一个对象。常用方法make_shared, use_count()

#include <iostream>
#include <string>
#include <memory>

using namespace std;

struct Person : enable_shared_from_this<Person>
{
    void show() {
        cout << str << endl;
    }
    shared_ptr<Person> getShared() {
        //return shared_ptr<Person>(this);   // 不会增加引用计数，会导致程序崩溃
        return shared_from_this();           // 会增加引用计数，位于enable_shared_from_this类中，就可以使用

    }
    string str;
};

int main() {
    /* demo1 */
    //shared_ptr<string> p1;     // 这么写的话use_count()值为0，因为为空
//  shared_ptr<string> p1(new string("hello"));   
//  cout << p1.use_count() << endl;                 // use_count() 为1
//  cout << *p1 << endl;
//  shared_ptr<string> p2 = p1;
//  cout << p1.use_count() << endl;                 // use_count() 为2


    /* demo2 */
//  shared_ptr<Person> ptr(new Person);
//  shared_ptr<Person> ptr2 = ptr->getShared();    // user_count()仍然是1
//  cout << ptr.use_count() << endl;                // 1
    // 这样的话程序在结束时，第一个对象销毁时，引用计数清零，原来的对象已经没了，引用计数要减1时访问不到对象了，导致崩溃
    // 总的来说要 1、不要把一个原生指针给多个共享指针管理
    //            2、不要把this指针给共享指针
    //            3、不要在函数实参里创建shared_ptr


    /* demo3 */
    shared_ptr<Person> ptr2;
    {
        shared_ptr<Person> ptr(new Person);
        ptr->str = "yyyy";
        ptr2 = ptr->getShared();
        cout << ptr.use_count() << endl;   // 不使用shared_from_this就是1，使用就是2
    }
    ptr2->show();   // 这里就无法访问。

}

五、weak_ptr 在头文件memory里

weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象. 进行该对象的内存管理的是那个强引用的 shared_ptr. weak_ptr只是提供了对管理对象的一个访问手段。weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。weak_ptr是用来解决shared_ptr相互引用时的死锁问题,如果说两个shared_ptr相互引用,那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。它是对对象的一种弱引用，不会增加对象的引用计数，和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给它，它可以通过调用lock函数来获得shared_ptr。
直接上代码

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

int main() {
//  weak_ptr<string> w_ptr(new string("aaa"));  //错误， weak_ptr 要由shared_ptr来初始化
    
    weak_ptr<string> w_ptr;
    {
        shared_ptr<string> s_ptr(new string("aaa"));
        cout << s_ptr.use_count() << endl;     //  1
        w_ptr = s_ptr;
        //cout << *w_ptr << endl;     //错误， weak_ptr要转化为shared_ptr才能访问原来的对象
        auto ptr = w_ptr.lock();    // 变成shared_ptr
        cout << *ptr << endl;
        cout << s_ptr.use_count() << endl;     //  1
    }
    if (w_ptr.expired())         // 检查被引用对象是否已经删除
        cout << "空了" << endl;
}