C++速览之智能指针

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

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

#include <iostream>using namespace std;int mian(){//1. 声明未初始化int *p1 ;cout << "打印p1: " << *p1 << endl;//2. 内存释放后，并没有置空 nullptrint *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 等指针来自动回收堆中分配的内存。智能指针的用法和原始指针用法一样，只是它多了些释放回收的机制罢了。

智能指针是 C++ 中为了避免内存泄漏等问题而引入的一种对象，它们是模板类，其行为类似于指针，但会自动管理所指向对象的生命周期。它们在构造时获取资源，在析构时释放资源，从而避免了手动调用delete操作符的需要

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();// 输出6cout << "-----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);
}

在这里插入图片描述

PS：

shared_ptr：
允许多个shared_ptr指向同一个对象，使用引用计数来管理对象的生命周期，当最后一个 shared_ptr 被销毁或不再指向该对象时，对象才会被删除

#include <iostream>
#include <memory>int main() {std::shared_ptr<int> ptr1 = std::make_shared<int>(10);std::shared_ptr<int> ptr2 = ptr1; std::cout << *ptr1 << " " << *ptr2 << std::endl; return 0;
}

std::make_shared(10)：创建一个shared_ptr并将其初始化为指向一个值为 10 的int对象；
std::shared_ptr ptr2 = ptr1;：ptr2和ptr1都指向同一个对象，它们会共享一个引用计数，当其中一个 shared_ptr 被销毁时，引用计数会减一，只有当引用计数为零时，对象才会被删除。

weak_ptr：
它是一种辅助 shared_ptr 的智能指针，不会影响所指向对象的生命周期。
主要用于解决 shared_ptr 的循环引用问题，因为循环引用会导致引用计数永远不为零，从而导致内存泄漏。

#include <iostream>
#include <memory>struct Node {std::shared_ptr<Node> next;~Node() { std::cout << "Node 被销毁" << std::endl; }
};int main() {std::shared_ptr<Node> node1 = std::make_shared<Node>();std::shared_ptr<Node> node2 = std::make_shared<Node>();node1->next = node2;node2->next = node1;// 存在循环引用，导致 Node 不会被销毁return 0;
}

为了解决上述问题，可以使用weak_ptr

#include <iostream>
#include <memory>struct Node {std::weak_ptr<Node> next;~Node() { std::cout << "Node 被销毁" << std::endl; }
};int main() {std::shared_ptr<Node> node1 = std::make_shared<Node>();std::shared_ptr<Node> node2 = std::make_shared<Node>();node1->next = node2;node2->next = node1;return 0;
}