目录

RAII

auto_ptr模拟实现 

 智能指针拷贝问题

唯一指针 

shared_ptr（可以拷贝） 

shared_ptr模拟实现 

完整代码 

循环引用 

weak_ptr模拟实现  

定制删除器

shared_ptr定制删除器模拟实现 

 内存泄漏

---

 

RAII

 RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内
存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在
对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做
法有两大好处：
不需要显式地释放资源。
采用这种方式，对象所需的资源在其生命期内始终保持有效.

此时释放了资源

 抛异常后没有释放资源

提供一个类 ，在该类的对象构造时获取资源，析构时释放资源

#include<iostream>
using namespace std;
//利用RAII设计的释放delete资源的类
template<class T>
class SmartPtr
{
public:SmartPtr(T* Ptr)//在构造的时候把资源给某个对象:_ptr(Ptr){}~SmartPtr()//析构的时候把资源进行释放{delete _ptr;cout << "资源释放 " <<"delete:" <<_ptr<< endl;}
private:T* _ptr;
};
int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void Func()
{// 1、如果p1这里new 抛异常会如何？// 2、如果p2这里new 抛异常会如何？// 3、如果div调用这里又会抛异常会如何？int* p1 = new int;int* p2 = new int;SmartPtr<int> sp1(p1);SmartPtr<int> sp2(p2);cout << div() << endl;
}
int main()
{try{Func();}catch (exception& e){cout << e.what() << endl;}return 0;
}

 抛异常也能进行正常的资源释放

 上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可
以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其
像指针一样去使用。

总结一下智能指针的原理：
1. RAII特性
2. 重载operator*和opertaor->，具有像指针一样的行为。

库里面的智能指针有很多，如auto——ptr

auto_ptr模拟实现 

	template<class T>class auto_ptr{public:auto_ptr(T* ptr = nullptr): _ptr(ptr){}auto_ptr(auto_ptr<T>& ap):_ptr(ap._ptr){ap._ptr = nullptr;}// ap1 = ap2;auto_ptr<T>& operator=(auto_ptr<T>& ap){if (this != &ap){if (_ptr){cout << "Delete:" << _ptr << endl;delete _ptr;}_ptr = ap._ptr;ap._ptr = nullptr;}return *this;}~auto_ptr(){if (_ptr){cout << "Delete:" << _ptr << endl;delete _ptr;}}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};

 智能指针拷贝问题

对上面我们写的类，创建俩个对象直接进行拷贝，程序会崩溃

这是因为对空间A析构了俩次，我们虽然没写拷贝构造函数但是这里_ptr是内置类型，对内置类型完成了值拷贝，然后在析构的时候对这块空间析构了俩次，导致程序直接崩溃

库里面的没有崩溃

auto_ptr的拷贝构造在拷贝的时候把资源进行了转移，ap1把资源直接转给了ap2，相当于把ap1进行了剪切，ap1被置空了

 

解决方案：

深拷贝：这里不能用深拷贝，因为违背了功能需求 ，智能指针我们不知道要拷贝多少，拷贝的资源有多大。智能指针只是帮助我们进行托管，像指针一样。这里需要的就是浅拷贝

唯一指针 

禁用了拷贝构造和赋值 ，其它功能都正常

 

 

template<class T>
class unique_ptr
{
private:// 防拷贝 C++98// 只声明不实现 //unique_ptr(unique_ptr<T>& ap);//unique_ptr<T>& operator=(unique_ptr<T>& ap);
public:unique_ptr(T* ptr = nullptr): _ptr(ptr){}// 防拷贝 C++11unique_ptr(unique_ptr<T>& ap) = delete;//拷贝构造是默认成员函数unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;~unique_ptr(){if (_ptr){cout << "Delete:" << _ptr << endl;delete _ptr;}}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;
};

 C++98只声明，不实现

 而且必须的私有，不然会报错

 私有化后，赋值和拷贝就不能使用了

 

shared_ptr（可以拷贝） 

 增加了引用计数，表示有n个对象管理这块资源

 

这里的计数不能用静态的， 

析构的时候--计数，减到0了就释放空间

 

出问题

 这里空间被释放了俩次 ，还有一次未被释放。

注释掉后面俩个，也被释放了俩次

 本应是这样，静态成员变量是所有类共享的

sp4 来了之后，计数又变为了1，因为类型不一样，由于这些计数是共享的导致sp1,sp2,sp3的计数也变成了1

 所以我们在这里采用指针，

一个资源，配一个计数，多个智能指针对象共管。

如果用静态计数，静态计数对象所有资源都只有一个计数， 因为静态成员属于整个类，属于类的所有对象。

shared_ptr模拟实现 

operator=

void Release(){if (--(*_pCount) == 0){cout << "Delete:" << _ptr << endl;delete _ptr;delete _pCount;}}shared_ptr<T>& operator=(const shared_ptr<T>& sp){//if (this == &sp)if (_ptr == sp._ptr){return *this;}// 减减被赋值对象的计数，如果是最后一个对象，要释放资源/*if (--(*_pCount) == 0){delete _ptr;delete _pCount;}*/Release();// 共管新资源，++计数_ptr = sp._ptr;_pCount = sp._pCount;(*_pCount)++;return *this;}

 如果没有中间的Realse，sp1指向sp5之后，图中最上面那块空间计数还是3，如果是0就直接释放空间

完整代码 

template<class T>
class shared_ptr
{
public:shared_ptr(T* ptr = nullptr): _ptr(ptr), _pCount(new int(1)){}void Release(){if (--(*_pCount) == 0){cout << "Delete:" << _ptr << endl;delete _ptr;delete _pCount;}}~shared_ptr(){Release();}// sp1(sp2)shared_ptr(const shared_ptr<T>& sp): _ptr(sp._ptr), _pCount(sp._pCount)//把计数也要给拷贝，拷贝完之后++即可{(*_pCount)++;}shared_ptr<T>& operator=(const shared_ptr<T>& sp){//if (this == &sp)if (_ptr == sp._ptr){return *this;}// 减减被赋值对象的计数，如果是最后一个对象，要释放资源/*if (--(*_pCount) == 0){delete _ptr;delete _pCount;}*/Release();// 共管新资源，++计数_ptr = sp._ptr;_pCount = sp._pCount;(*_pCount)++;return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;// 引用计数int* _pCount;
};

循环引用 

 C++98不支持n2这种方式，必须得和n1一样，不允许隐式类型转换

 此时会报错，因为n2是智能指针，next是原生指针

将next改成智能指针后，程序可以正常运行

 

n2->prve指向n1

此时又不释放空间

 这是因为函数结束得时候，n2先析构，n1后析构

 next析构右边就释放(delete)，prev析构左边就释放（delete），_next在左边，左边的节点被delete时调用析构函数，_next作为成员才会析构，而要释放左边的节点,_prev就得先释放，释放_prev就要先释放右边的节点，右边的节点是否释放又取决于_next，所以俩边互相克制

用weak_ptr就能解决这种问题，这不是常规的智能指针，没有RAII，不支持直接管理资源，wak_ptr主要用于shared_ptr构造，用来解决shared_ptr的循环引用问题。

 _next和_prev时weak_ptr时，他不参与释放资源管理，可以访问和修改到资源，但是不增加计数，不存在循环引用的问题

shared_ptr中有一个use_count专门用来查看计数

  

这里可以看到赋值前后的计数没有变 

weak_ptr模拟实现  

weak_ptr是辅助型智能指针，解决配合shared_ptr循环引用问题 

 

namespace bit
{template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr): _ptr(ptr), _pCount(new int(1)){}void Release(){if (--(*_pCount) == 0){cout << "Delete:" << _ptr << endl;delete _ptr;delete _pCount;}}~shared_ptr(){Release();}// sp1(sp2)shared_ptr(const shared_ptr<T>& sp): _ptr(sp._ptr), _pCount(sp._pCount)//把计数也要给拷贝，拷贝完之后++即可{(*_pCount)++;}shared_ptr<T>& operator=(const shared_ptr<T>& sp){//if (this == &sp)if (_ptr == sp._ptr){return *this;}// 减减被赋值对象的计数，如果是最后一个对象，要释放资源/*if (--(*_pCount) == 0){delete _ptr;delete _pCount;}*/Release();// 共管新资源，++计数_ptr = sp._ptr;_pCount = sp._pCount;(*_pCount)++;return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}int use_count(){return *_pCount;}T* get()const//直接获得指针{return _ptr;}private:T* _ptr;// 引用计数int* _pCount;};template <class T>class weak_ptr{public:weak_ptr():_ptr(nullptr){}weak_ptr(const shared_ptr<T>& sp):_ptr(sp.get()){}weak_ptr(const weak_ptr<T>& sp)//俩个拷贝构造函数:_ptr(sp._ptr){}//不写析构，不释放资源T& operator*(){return *_ptr;}T* operator->(){return _ptr;}weak_ptr<T>& operator=(const shared_ptr<T>& sp){//这里赋值不需要考虑释放资源，因为weak_ptr不参与管理资源_ptr = sp.get();return *this;}private:T* _ptr;};
}
struct Node
{int _val;bit::shared_ptr<Node> _next;bit::shared_ptr<Node> _prev;~Node(){cout << "~Node" << endl;}
};

  

 

没有增加引用计数，没有打印delete 

定制删除器

 

 

程序直接崩掉，因为没有匹配使用

当换成内置类型后，程序正常运行

 

当屏蔽掉自定义类型的析构函数时，程序不会报错，当析构函数存在时，函数会报错

这些问题跟new实现相关，new底层调用malloc，delete底层调用free， vs平台上new内置类型[5]，如new int[5]，用delete释放没问题，但是在其它平台上可能会出问题，对于自定义类型要调构造函数和析构函数。

 

如果不写析构函数，编译器就会进行优化，对析构函数就不再调用，就只剩free,所以不会报错，当析构函数写了，就会调用，我们new Node[5],而delete却不知道要调用多少次析构函数，delete不知道[]中的数字，语法规定delete使用时是delete[],所以delete不知道要析构多少次。

vs下如果要开60byte空间，会多给4byte，总共开64byte，这4个byte用来记录次数

 当释放的时候把ptr强转为char*然后-4，ptr此时指向记录次数这块空间，然后转为int*，再解引用就可获得析构次数，之后开始调用析构函数，free的时候，free的是ptr-4这个位置就是开头的位置。

 

shared_ptr的定制删除器 ，del可以是仿函数

 unique_ptr也支持

跟C++11相结合

 

 

 unique必须跟传模板参数一样，传过去

 

 

模仿shared_ptr这种方式也不行

 需要这样传参

 

 当我们自己要模拟实现定制删除器时，我们上面写的shared_ptr和unique_ptr都无法支持定制删除器。

在类模板增加一个参数D，当引用计数--后等于0时， 下面是调用D operator(),根据D重载()的内容，对ptr进行处理

写一个删除器

 

shared_ptr定制删除器模拟实现 

template<class T>
struct Delete
{void operator()(T* ptr){cout << "delete:" << ptr << endl;delete ptr;}
};template<class T, class D = Delete<T>>
class shared_ptr
{
public:shared_ptr(T* ptr = nullptr): _ptr(ptr), _pCount(new int(1)){}void Release(){if (--(*_pCount) == 0){//cout << "Delete:" << _ptr << endl;//delete _ptr;//D del;//del(_ptr);D()(_ptr);delete _pCount;}}~shared_ptr(){Release();}// sp1(sp2)shared_ptr(const shared_ptr<T>& sp): _ptr(sp._ptr), _pCount(sp._pCount){(*_pCount)++;}shared_ptr<T>& operator=(const shared_ptr<T>& sp){//if (this == &sp)if (_ptr == sp._ptr){return *this;}// 减减被赋值对象的计数，如果是最后一个对象，要释放资源/*if (--(*_pCount) == 0){delete _ptr;delete _pCount;}*/Release();// 共管新资源，++计数_ptr = sp._ptr;_pCount = sp._pCount;(*_pCount)++;return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}int use_count(){return *_pCount;}T* get() const{return _ptr;}private:T* _ptr;// 引用计数int* _pCount;
};

这里必须显示的传第二个模板参数，不然delete次数会匹配不上，程序会崩溃

 内存泄漏

 C/C++程序中一般我们关心两种方面的内存泄漏：
堆内存泄漏(Heap leak)
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一
块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分
内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
系统资源泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放
掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

 如何检测内存泄漏（了解）
在linux下内存泄漏检测：(39条消息) Linux下几款C++程序中的内存泄露检查工具_CHENG Jian的博客-CSDN博客_linux c++ 内存泄露 检测
在windows下使用第三方工具：(39条消息) VS编程内存泄漏：VLD(Visual LeakDetector)内存泄露库_波波在学习的博客-CSDN博客
其他工具：内存泄露检测工具比较 - 默默淡然 - 博客园 (cnblogs.com)

 内存泄漏是指针丢了还是内存丢了？

答：指针丢了，通过指针去释放指针，内存本身不存在丢失，当进程正常结束，内存也会释放，要避免僵尸进程和长期运行的程序的内存泄漏。

 如何避免内存泄漏
1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：
这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智
能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。

3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
总结一下:
内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄
漏检测工具。