智能指针（内存泄漏问题）
🌻个人主页：路飞雪吖~
🌠专栏：C/C++
目录
一、为什么需要智能指针？
二、内存泄露
三、智能指针的使用及原理
⭐RAII
⭐智能指针的原理
🌠小贴士：
⭐std::auto_ptr
编辑 ✨auto_ptr模拟实现
⭐std::unique_ptr
✨unique_ptr 的模拟实现
🌠小贴士：
✨std::weak_ptr的模拟实现
四、C++11和boost中智能指针的关系
一、为什么需要智能指针？
下面我们先分析一下下面这段程序有没有什么内存方面的问题？
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;cout << div() << endl;delete p1;delete p2;
}int main()
{try{Func();}catch (exception& e){cout << e.what() << endl;}return 0;
}
1、如果p1这里new 抛异常会如何？不用管，因为还没有东西申请出来。
2、如果p2这里new 抛异常会如何？要先释放p1。3、如果div调用这里又会抛异常会如何？ 要释放p1和p2。
二、内存泄露
⭐内存泄露的危害
• 什么是内存泄漏？
内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内 存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对 该段内存的控制，因而造成了内存的浪费。
• 内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现 内存泄漏会导致响应越来越慢，最终卡死。
void MemoryLeaks()
{// 1.内存申请了忘记释放int* p1 = (int*)malloc(sizeof(int));int* p2 = new int;// 2.异常安全问题int* p3 = new int[10];Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.delete[] p3;
}⭐内存泄露的分类
C/C++程序中一般我们关心两种方面的内存泄漏：
• 堆内存泄漏(Heap leak)
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一 块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分 内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
• 系统资源泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放 掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
三、智能指针的使用及原理
⭐RAII
RAII（Resource Acquisition Is Initialization）是一种 利用生命周期来控制程序资源（如内存、文件句柄、网络连接等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种方法有两大好处：
• 不需要显式的释放资源；
• 采用这种方式，对象所需的资源在其生命期内始终保持有效。
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:SmartPtr(T* ptr = nullptr)// 在对象构造时获取资源: _ptr(ptr){}~SmartPtr() // 最后在对象析构的时候释放资源{if(_ptr)delete _ptr;}private:T* _ptr;
};int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}void Func()
{ShardPtr<int> sp1(new int);ShardPtr<int> sp2(new int);cout << div() << endl;
}// 好处：
// 不需要显式地释放资源
// 采用这种方式，对象所需的资源在其生命期内始终保持有效int main()
{try{Func();}catch(const exception& e){cout<<e.what()<<endl;}return 0;
}
⭐智能指针的原理
上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用 * ，也可以通过 -> 去访问所指空间中的内容，因此：SmartPtr模板类中还得需要将 * 、 -> 重载，才可让其像指针一样去使用。
template<class T>
class SmartPtr {
public:SmartPtr(T* ptr = nullptr): _ptr(ptr){}~SmartPtr(){if(_ptr)delete _ptr;}T& operator*() {return *_ptr;}T* operator->() {return _ptr;}private:T* _ptr;
};
struct Date
{int _year;int _month;int _day;
};int main()
{SmartPtr<int> sp1(new int);*sp1 = 10cout<<*sp1<<endl;SmartPtr<int> sparray(new Date);// 需要注意的是这里应该是sparray.operator->()->_year = 2018;// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->sparray->_year = 2018;sparray->_month = 1;sparray->_day = 1;
}🌠小贴士：
总结一下智能指针的原理：
1. RAII特性;
2. 重载operator*和opertaor->，具有像指针一样的行为。
⭐std::auto_ptr
C++98版本的库中就提供了auto_ptr的智能指针；
auto_ptr 的实现原理：管理权转移的思想。
有些地方明确要求 禁止使用！
template<class T>
class SmartPtr {
public:SmartPtr(T* ptr = nullptr): _ptr(ptr){}~SmartPtr(){if (_ptr)delete _ptr;}T& operator*() { return *_ptr; }T* operator->() { return _ptr; }
private:T* _ptr;
};struct Date
{int _year;int _month;int _day;Date(int year = 1, int month = 1, int day = 1):_year(year), _month(month), _day(day){}~Date(){cout << "~Date()" << endl;}
};int main()
{//SmartPtr<Date> sp1(new Date);//SmartPtr<Date> sp2(sp1);//浅拷贝/值拷贝（sp1、sp2指向同一块空间，析构两次，导致程序错误）auto_ptr<Date> ap1(new Date);// 拷贝时，管理权限转移，被拷贝(ap1)悬空auto_ptr<Date> ap2(ap1);ap1->_year++;return 0;
}
✨auto_ptr模拟实现
// auto_ptr
namespace xlf
{template<class T>class auto_ptr{public:auto_ptr(T* ptr):_ptr(ptr){}// sp1(sp2)auto_ptr(auto_ptr<T>& sp):_ptr(sp._ptr){//管理权转移sp._ptr = nullptr;}auto_ptr<T>& operator=(auto_ptr<T>& ap){//检测是否为自己给自己赋值if (this != &ap){// 释放当前对象中资源if (_ptr)delete _ptr;// 转移ap中资源到当前对象中_ptr = ap._ptr;ap._ptr = NULL;}return *this;}~auto_ptr(){if (_ptr){cout << "delete:" << _ptr << endl;delete _ptr;}}// 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
}// 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr
//int main()
//{
// std::auto_ptr<int> sp1(new int);
// std::auto_ptr<int> sp2(sp1); // 管理权转移
//
// // sp1悬空
// *sp2 = 10;
// cout << *sp2 << endl;
// cout << *sp1 << endl;
// return 0;
//}⭐std::unique_ptr
C++11中开始提供更靠谱的unique_ptr；
unique_ptr的实现原理：简单粗暴的防拷贝。
🔥扩展：
Boost库：为C++语言标准库提供扩展C++程序库的总称。
Boost库是为C++语言标准库提供扩展的一些C++程序库的总称，由Boost社区组织开发、维护。Boost库可以与C++标准库完美共同工作，并且为其提供扩展功能。
Boost 功能 引入C++11 scoped_ptr /
scoped_array
禁止拷贝 unique_ptr shared_ptr /
shared_array
引用计数的方式支持 shared_ptr weak_ptr 不同于上面的智能指针，
不支持直接管理资源，
配合解决 shared_ptr 的一个缺陷，
循环引用会导致内存泄露。
weak_ptr
template<class T>
class DeleteArray
{
public:void operator()(T* ptr){delete[] ptr;}
};class Fclose
{
public:void operator()(FILE* ptr1){cout << "fclose:" << ptr1 << endl;Fclose(ptr);}
};int main()
{// C++11unique_ptr<Date> up1(new Date);// 不支持拷贝(拷贝会被悬空)//auto_ptr<Date> up2(up1);//定制删除器//unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);// delete[] 不匹配，要单独写unique_ptr<Date[]> up2(new Date[5]);//调用特化版本unique_ptr<FILE, Fclose> up3(fopen("test.cpp","r"));
}✨unique_ptr 的模拟实现
// C++11库才更新智能指针实现
// C++11出来之前，boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr// unique_ptr/scoped_ptr
// 原理：简单粗暴 -- 防拷贝namespace xlf
{template<class T>class unique_ptr{public:unique_ptr(T* ptr):_ptr(ptr){}~unique_ptr(){if (_ptr){delete _ptr;}}// 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}// 禁止拷贝unique_ptr(const unique_ptr<T>& sp) = delete;unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;private:T* _ptr;};
}int main()
{xlf::unique_ptr<int> sp1(new int);//xlf::unique_ptr<int> sp2(sp1);不能进行拷贝std::unique_ptr<int> sp1(new int);//std::unique_ptr<int> sp2(sp1);不能进行拷贝return 0;
}⭐std::shared_ptr
C++11中开始提供更靠谱的并且支持拷贝的shared_ptr；
shared_ptr 的原理：是通过引用计数的方式来实现多个 shared_ptr 对象之间共享资源。
int main()
{//vector<shared_ptr<Date>> v; 涉及左值右值要拷贝的场景shared_ptr<Date> sp1(new Date);shared_ptr<Date> sp2(sp1);// 多个对象共享资源shared_ptr<Date> sp3(sp2);cout << sp1.use_count() << endl;shared_ptr<Date[]> sp4(new Date[5]);//shared_ptr<FILE, Fclose> up4(fopen("test.cpp", "r"));//不支持在类模板参数传，要在构造函数的参数去传shared_ptr<FILE> up4(fopen("test.cpp", "r"), Fclose());//要在构造函数的参数去传shared_ptr<Date> sp6 = make_shared<Date>(2024, 8, 5);return 0;
}
✨std::shared_ptr的模拟实现
☄️我们如何设计引用计数？
引用计数是共同管理一块资源，共同的一个技术，而不是各自有一个各自的技术。
☄️ 定制删除器如何设计？
采用function包装器：
#include<functional>
namespace xlf
{template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr):_ptr(ptr), _pcount(new int(1)){}// D函数模板是给 del这个成员函数用的，不是给整个类用的// 只有把D写成类模板才能用，但是库里面没有写成类模板，只有unique_ptr写成类模板template<class D>//定制删除器:即可调用对象shared_ptr(T* ptr, D del)// 困境：删除器要传到release,:_ptr(ptr) // release要给删除和operator=用，,_pcount(new int(1)) // 所以release要改变,_del(del) //成员函数里面，一个类的要给另外一个类的用的话，要通过成员变量{}//sp2(sp1)shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr), _pcount(sp._pcount){++(*_pcount);}void Release(){if (--(*_pcount) == 0){//delete _ptr;_del(_ptr);delete _pcount;_ptr = nullptr;_pcount = nullptr;}}//sp1=sp3 const会引用左值也会引用右值shared_ptr& operator=(const shared_ptr<T>& sp)// 如果是一个右值可以转移资源{造成内存泄露//_ptr = sp._ptr;//_pcount = sp._pcount;//++(*_pcount);//return *this;if (_ptr != sp._ptr)//防止自己给自己赋值{Release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}~shared_ptr(){Release();}T* get() const{return _ptr;}int use_count() const {return *_pcount;}T& operator*() { return *_ptr; }T* operator->() { return _ptr; }private:T* _ptr;int* _pcount;//增加引用计数//D _del;可调用对象function<void(T* ptr)> _del = [](T* ptr) {delete ptr; };//删除器};
}struct Date
{int _year;int _month;int _day;Date(int year = 1, int month = 1, int day = 1):_year(year), _month(month), _day(day){}~Date(){cout << "~Date()" << endl;}
};class Fclose
{
public:void operator()(FILE* ptr1){cout << "fclose:" << ptr1 << endl;Fclose(ptr);}
};#include"shared_ptr.h"int main()
{xlf::shared_ptr<Date> sp1(new Date);// 没传删除器，此时调用function(包装器)的默认构造，// 但是function里面没有可调用对象，会报错，// 因此function要给缺省值_ptr,回调自己xlf::shared_ptr<Date> sp2(sp1);xlf::shared_ptr<Date> sp3(new Date);//自己给自己赋值sp3 = sp3;//出现问题，此时，sp3只有一个对象管理sp1 = sp2;sp1 = sp3;xlf::shared_ptr<FILE> sp5(fopen("test.cpp", "r"), Fclose());xlf::shared_ptr<int> sp6((int*)malloc(40), [](int* ptr){cout << "free:" << ptr << endl;free(ptr);});return 0;
}
🌠小贴士：
严格来说，不是深拷贝的类都不需要移动构造，浅拷贝的类，移动构造和移动赋值都没有特别大的意义，所以不需要实现，编译器一般也不会默认生成。
✨std::shared_ptr的循环引用问题
struct ListNode
{int _data;//ListNode* _next;//ListNode* _prev;std::shared_ptr<ListNode> _next;std::shared_ptr<ListNode> _prev;~ListNode(){cout << "~ListNode()" << endl;}
};int main()
{//循环引用的场景---（互相指向）导致内存泄露//std::shared_ptr<ListNode> n1 = new ListNode;//不支持这样子给，因为它的构造加了explicit，所以不支持转换std::shared_ptr<ListNode> n1(new ListNode);std::shared_ptr<ListNode> n2(new ListNode);cout << n1.use_count() << endl;cout << n2.use_count() << endl;//n1->_next = n2;// 不能， n1->_next是原生指针 n2是智能指针对象，// 智能指针不能给原生指针，所以要把原生指针的类型改为智能指针//互相指向造成内存泄露（没有析构）n1->_next = n2;// errorn2->_prev = n1;// errorcout << n1.use_count() << endl;cout << n2.use_count() << endl;//std::weak_ptr<ListNode> wp(new ListNode);return 0;
}
解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了；
原理就是：node1->_next = node2 和 node2->_prev = node1时 weak_ptr的_next和 _prev不会增加node1和node2的引用计数。
struct ListNode
{int _data;// weak_ptr的特点，当你用shared_ptr赋值或者拷贝构造时，不增加引用计数// 意味着我指向了它，但是我不增加计数std::weak_ptr<ListNode> _next;std::weak_ptr<ListNode> _prev;~ListNode(){cout << "~ListNode()" << endl;}
};int main()
{//循环引用的场景---（互相指向）导致内存泄露std::shared_ptr<ListNode> n1(new ListNode);std::shared_ptr<ListNode> n2(new ListNode);n1->_next = n2;n2->_prev = n1;return 0;
}✨std::weak_ptr的模拟实现
weak_ptr的特点：当你用shared_ptr赋值或者拷贝构造时，不增加引用计数，意味着我指向了它，但是我不增加计数。
template<class T>
class weak_ptr
{
public:weak_ptr(){}weak_ptr(const shared_ptr<T>& sp)//拷贝构造:_ptr(sp.get())// 不增加 shared_ptr的引用计数,严格来说，weak_ptr是要拿到计数的，才能判断过期{}weak_ptr<T>& operator=(const shared_ptr<T>& sp){_ptr = sp.get();return *this;}private:T* _ptr = nullptr;T* _pcount;
};四、C++11和boost中智能指针的关系
1. C++ 98 中产生了第一个智能指针auto_ptr.
2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。
需要注意的是unique_ptr对应boost 的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。
如若对你有帮助，记得点赞、收藏、关注哦！
若有误，望各位，在评论区留言或者私信我 指点迷津！！！谢谢^ ^ ~