【C++】智能指针
1. 为什么需要智能指针？
若p1处new抛异常，则相当于p1的new没有成功，则什么都不用做
若p2处new抛异常，则相当于p2的new没有成功，而p1的new成功了，所以需要释放p1，然后再重新抛出
若div处抛异常，则将p1与p2都释放，再将其重新抛出
可以看出处理起来非常麻烦，存在内存泄漏的问题(只进行new，但没有delete) 第二个new抛异常要释放第一个new，div抛异常要释放前两个new 若再添加一个new，则又会存在new抛异常的问题，还需添加 try catch
为了提前预防内存泄漏的问题，就提出了智能指针
2. 智能指针的使用
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内 存、文件句柄、网络连接、互斥量等等）的简单技术。 在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，在 对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做 法有两大好处： 不需要显式地释放资源 对象所需的资源在其生命期内始终保持有效
RAII是一种思想，智能指针是这种思想的产物
智能指针的常见问题
1.使用对象的生命周期去控制资源
创建一个私有的成员变量 _ptr指针 在构造函数时，将指针保存起来 在析构函数时，将指针释放
将申请的资源，交给智能指针对象去管理 (通过这个指针 去构造一个智能指针对象,这个对象会把指针保留起来)
创建对象时，会调用构造函数，将new int 传给类中的指针，对象会把指针保留起来 v1和v2属于局部对象，出了作用域时，就会调用析构函数 ，完成释放
若第一个new抛异常，就不会进入构造函数中 若第二个new抛异常，则调用析构，将第一个new释放掉 若div抛异常，则v1和v2对象都调用析构，将第一个new和第二个new都释放掉
通过类的构造和析构的自动调用，利用对象的生命周期来管理资源，被称之为 RAII
2. 像指针一样使用
在类中实现 operator() 和operator->，使对象可以进行解引用 和->访问成员的操作
3. 拷贝问题
因为没有在类中实现拷贝构造，默认是浅拷贝 ，所以就会导致释放两次，从而报错
深拷贝是不可以的，因为指针拷贝要的就是浅拷贝
链表等迭代器 结构与智能指针类似，用的是浅拷贝，为什么没有问题？ 因为迭代器不管资源的释放，资源释放是容器处理的 智能指针需要管资源释放，所以不能单纯的浅拷贝
auto_ptr ——管理权转移
当上述v1和v2都管理这个资源就会有问题，两者都会去释放，导致释放两次
所以C++98版本的库中就提供了auto_ptr的智能指针，提出了 管理权转移的思想
官方文档：auto_ptr
将管理权只给一个对象，剩下一个对象去除管理权
如果不了解管理权转移的特性，就不知道v1已经为空，依旧对v1进行解引用，就会报错 因为管理权转移后，v1悬空不能访问
所以管理权转移，存在被拷贝对象悬空的问题
unique_ptr ——防拷贝
官方文档：unique_ptr
在C++98和C++11之间 产生了一个 库 boost (准标准库) 在boost中 就把智能指针的问题解决了 boost 中包含 scoped_ptr shared_ptr weak_ptr 体系
C++11将其吸收过来以后，将 scoped_ptr 改成 unique_ptr ,其他没变 即 unique_ptr shared_ptr weak_ptr unique_ptr的特点为 简单 粗暴 防拷贝 (不需要拷贝的场景)
C++98版本
拷贝构造和赋值是默认成员函数，若自己不实现，会自动生成，所以必须写 但是写又不知道写什么，所以C++98思路是只声明，不实现
只在 类里面声明是不可以的，因为在类外可以实现 所以还要声明成私有
C++11版本
使用禁止生成默认函数的关键字 delete
不受公有 或者 私有的 影响
shared_ptr (根本解决拷贝问题)
官方文档：shared_ptr
特点为使用引用计数，支持拷贝
有两个对象指向资源，当析构时，会析构两次 为了解决这个问题，就增加一个引用计数，若只有一个对象，就为1，若为两个对象，则为2
当其中一个对象要析构时，就先看引用计数，若引用计数减1还大于0，就要什么都不管 若引用计数减1为0，则表示最后一个管理这块资源的对象，就可以将其释放掉
若将引用计数设置为静态 (静态的成员 是属于这个类的所有对象)
对象C指向与 对象A /B不同的资源，当对 C进行释放时，也会影响到对A和B的引用计数的值 所以不能使用 静态的引用计数
每个资源都应该配对一个引用计数
new一个引用计数 对象除了指向资源，也要指向引用计数
在构造时，先new一块空间，让_pcount指向这块空间
只有当引用计数 为0时，才会去析构 释放
拷贝构造是浅拷贝，通过引用计数的方式，每次有一个对象指向资源，就使引用计数+1
赋值
情况1
若将对象C赋值给对象A，则使对象A指向对象C的资源处 ，同时对象B的引用计数-1，对象C的引用计数+1
情况2
若将对象A赋值给对象C，则对象C原本指向的引用计数为0，该资源要被释放
代码实现
namespace yzq
{
template<class T>
class shared_ptr
{
public:
//构造
shared_ptr(T* ptr)
:_ptr(ptr)
,_pcount(new int(1))
{}
//析构
~shared_ptr()
{
Release();
}
void Release()
{
//若引用计数-- 后为0，则说明为最后一个对象 就进行释放
if (--(*_pcount) == 0)
{
cout << "delete: " << _ptr << endl;
//释放资源和引用计数
delete _ptr;
delete _pcount;
}
}
void Addcount()
{
++(*_pcount);
}
//拷贝构造(浅拷贝)
shared_ptr(const shared_ptr<T>&sp)
:_ptr(sp._ptr)
,_pcount(sp._pcount)
{
//拷贝后将计数++
Addcount();
}
//赋值
shared_ptr<T>& operator=(const shared_ptr<T>&sp)
{
//若指向同一块资源 就不需要赋值
if (_ptr != sp._ptr)
{
//被赋值的对象 引用计数--
if (--(_pcount) == 0)
{
//若为0，则释放资源和引用计数
delete _ptr;
delete _pcount;
}
//改变指向
_ptr = sp._ptr;
_pcount = sp._pcount;
//改变指向后的对象 的引用计数++
(*_pcount)++;
}
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* get()//获取指针
{
return _ptr;
}
private:
T* _ptr;
int* _pcount;
};
void test_shared()
{
shared_ptr<int>v1(new int(1));
shared_ptr<int>v2(v1);
}
} weak_ptr —— 循环引用
new出两个节点，将两个节点链接起来，再删除节点
但是n1与n2链接时，可能会抛异常，会没有释放 所以将其改为使用智能指针
使用智能指针就进行释放了
n1和n2作为智能指针对象，而next和prev作为原生指针 智能指针对象是没办法给原生指针的
将next和prev都转化为智能指针即可 解决问题 但是节点不释放了
节点使用原生指针可以释放，而使用智能指针不能释放，这样的问题被称为循环引用
n1与n2都是智能指针，分别去管理资源
n2对应的引用计数为1，将n1的_next指向n2，导致n2的引用计数加1
n1的引用计数为1，将n2的_prev指向n1，导致n1的引用计数加1
出了作用域，先将n2节点析构，使其引用计数减1，此时n2的引用计数为1，还有一个_next的智能指针指向n2，只有当_next析构n2才能析构，而_next是随着n1节点析构而析构 再将n1节点析构，使其引用计数减1，此时n1的引用计数为1，还有一个_prev的智能指针指向n1，只有当_prev析构n1才能析构，而_prev是随着n2节点析构而析构
就造成了循环引用，从而导致内存泄漏
库中为了解决循环引用的问题，所以提出了 weak_ptr(弱指针)
特点： 不是常规的智能指针，不支持RAII(利用对象生命周期来控制程序资源) 支持像指针一样 专门设计出来辅助解决 shared_ptr的循环引用问题
将_next和_prev改为 weak_ptr即可解决问题 使用weak_ptr可以指向资源，但不参与管理，不增加引用计数
腾讯云开发者
