C++速览之智能指针

1、存在的问题
c++ 把内存的控制权对程序员开放，让程序显式的控制内存，这样能够快速的定位到占用的内存，完成释放的工作。但是此举经常会引发一些问题，比如忘记释放内存。由于内存没有得到及时的回收、重复利用，所以在一些c++程序中，常会遇到程序突然退出、占用内存越来越多，最后不得不选择重启来恢复。造成这些现象的原因可以归纳为下面几种情况.

1.1 野指针
出现野指针的有几个地方 :
指针声明而未初始化，此时指针的将会随机指向；
内存已经被释放、但指针仍然指向它。这时内存有可能被系统重新分配给程序使用，从而会导致无法估计的错误；

#include <iostream>

using namespace std;

int mian(){
    //1. 声明未初始化
    int *p1 ;
    cout << "打印p1: " << *p1 << endl;
    
    
    //2. 内存释放后，并没有置空 nullptr
    int *p = new int(55);

    cout << "释放前打印 :  " << *p << endl;

    delete  p ;
    cout << "释放后打印 :  " << *p << endl;
    
    return 0 ;
}

1.2 重复释放
程序试图释放已经释放过的内存，或者释放已经被重新分配过的内存，就会导致重复释放错误.

int main(){

    int *p = new int(4);

    //重复释放
    delete p;
    delete p;

    return 0 ;
}

1.3 内存泄漏
不再使用的内存，并没有释放，或者忘记释放，导致内存没有得到回收利用。 忘记调用delete

int main(){

    int *p = new int(4);
    
    
    //后面忘记调用delete p;

    return 0 ;
}

2、智能指针
为了解决普通指针的隐患问题，c++在98版本开始追加了智能指针的概念，并在后续的11版本中得到了提升
c++11标准用 unique_ptr | shared_ptr | weak_ptr 等指针来自动回收堆中分配的内存。智能指针的用法和原始指针用法一样，只是它多了些释放回收的机制罢了。

2.1 unique_ptr
unique_ptr 是一个独享所有权的智能指针，它提供了严格意义上的所有权
也就是只有这个指针能够访问这片空间，不允许拷贝，但是允许移动（转让所有权）

#include<iostream>
#include <memory>

using namespace std;

int main() {


    // 1. 创建unique_ptr对象，包装一个int类型指针
    unique_ptr<int> p(new int(10));

    // 2. 无法进行拷贝。编译错误
    //unique_ptr<int> p2 = p;
    cout << "-----1----" << *p << endl;

    // 3. 可以移动指针到p3. 则p不再拥有指针的控制权 p3 现在是唯一指针
    unique_ptr<int> p3 = move(p);
    cout << "-----2----" << *p3 << endl;

    // p 现在已经无法取值了。
    // cout << "-----3----" << *p << endl;

    // 可以使用reset显式释放内存。
    p3.reset();

    // 重新绑定新的指针
    p3.reset(new int(6));

    // 获取到包装的int类型指针
    int *p4 = p3.get();

    // 输出6
    cout << "-----4----" << "指针指向的值是：" << *p4 << endl;
    cout << "-----5----" << "*p3值是：" << *p3 << endl;

    return 0;
}

2.2 shared_ptr
shared_ptr : 允许多个智能指针共享同一块内存，由于并不是唯一指针，所以为了保证最后的释放回收，采用了计数处理，每一次的指向计数 + 1 ， 每一次的reset会导致计数 -1 ，直到最终为0 ，内存才会最终被释放掉。 可以使用use_cout 来查看目前的指针个数

#include <iostream>
#include <memory>

using namespace std;

class Stu {
public:
    Stu() {
        cout << "执行构造函数" << endl;
    }

    ~Stu() {
        cout << "执行析构函数" << endl;
    }
};

int main() {
    shared_ptr<Stu> s1(new Stu());
    cout << " ---1--- = " << s1.use_count() << endl;  // 查看指向计数
    shared_ptr<Stu> s2 = s1;
    cout << " ---2--- = " << s1.use_count() << endl;  // 查看指向计数
    shared_ptr<Stu> s3 = s1;
    cout << " ---3--- = " << s1.use_count() << endl;  // 查看指向计数
    s1.reset();
    cout << " ---4--- = " << s3.use_count() << endl;  // 查看指向计数
    s2.reset();
    cout << " ---5--- = " << s3.use_count() << endl;  // 查看指向计数
    s3.reset();  // 至此全部解除指向 计数为0 。 会执行stu的析构函数
    cout << " ---6--- = " << s3.use_count() << endl;  // 查看指向计数

    return 0;
}

问题
对于引用计数法实现的计数，总是避免不了循环引用（或环形引用）的问题，即我中有你，你中有我，shared_ptr也不例外。 下面的例子就是，这是因为f和s内部的智能指针互相指向了对方，导致自己的引用计数一直为1，所以没有进行析构，这就造成了内存泄漏

#include <iostream>
#include <memory>

using namespace std;

class Son;

class Father {
private:
    shared_ptr<Son> son;
public:
    Father() {
        cout << "father 构造" << endl;
    }

    ~Father() {
        cout << "father 析构" << endl;
    }

    void setSon(shared_ptr<Son> son) {
        this->son = son;
    }
};

class Son {
private:
    shared_ptr<Father> father;
public:
    Son() {
        cout << "son 构造" << endl;
    }

    ~Son() {
        cout << "son 析构" << endl;
    }

    void setFather(shared_ptr<Father> father) {
        this->father = father;
    }
};


int main() {
    shared_ptr<Father> f(new Father());
    shared_ptr<Son> s(new Son());
    f->setSon(s);
    s->setFather(f);
}

解决办法
定义对象的时候，用shared_ptr指针；引用对象的地方，用weak_ptr指针

2.3 weak_ptr

#include <iostream>
#include <memory>

using namespace std;

class Son;

class Father {
private:
    weak_ptr<Son> son;
public:
    Father() {
        cout << "father 构造" << endl;
    }

    ~Father() {
        cout << "father 析构" << endl;
    }

    void setSon(shared_ptr<Son> son) {
        this->son = son;
    }
};

class Son {
private:
    weak_ptr<Father> father;
public:
    Son() {
        cout << "son 构造" << endl;
    }

    ~Son() {
        cout << "son 析构" << endl;
    }

    void setFather(shared_ptr<Father> father) {
        this->father = father;
    }
};


int main() {
    shared_ptr<Father> f(new Father());
    shared_ptr<Son> s(new Son());
    f->setSon(s);
    s->setFather(f);
}