【C++：智能指针】破解C++内存泄漏：原理、用法与避坑实战(从 RAII 到循环引用)
·
🔥小叶-duck：个人主页
❄️个人专栏：《Data-Structure-Learning》《C++入门到进阶&自我学习过程记录》
《算法题讲解指南》--优选算法
《算法题讲解指南》--递归、搜索与回溯算法
《算法题讲解指南》--动态规划算法
✨未择之路，不须回头
已择之路，纵是荆棘遍野，亦作花海遨游
目录
1.2 unique_ptr：独占式智能指针（推荐优先使用）
前言
在 C++ 开发中，内存泄漏是长期困扰开发者的核心痛点 —— 手动管理 new/delete 时，一旦遇到异常、跳转或疏忽，就可能导致资源无法及时释放。而智能指针的出现，通过 RAII（资源获取立即初始化）机制完美解决了这一问题：它将资源托管给对象，利用对象生命周期结束前会自动释放资源，让开发者无需关注手动释放，专注业务逻辑。
本文结合从智能指针的设计思想（RAII）入手，详解 C++ 标准库中 unique_ptr、shared_ptr、weak_ptr 的用法、原理、模拟实现、适用场景，再到删除器定制、循环引用解决、线程安全等实战问题，帮你彻底掌握智能指针。
一、智能指针的核心：RAII 设计思想
1、为什么需要智能指针？
手动管理内存的致命问题：异常导致资源泄漏。
例如下面的代码：new了以后，我们也delete了，但是因为存在除0错误抛异常，后面的delete没有得到执行，所以就内存泄漏了。所以我们需要new以后捕获异常，捕获到异常后delete内存，再把异常重新抛出。
但是因为new本身也可能抛异常(new的空间过大等情况)，连续的两个new和下面的Divide都可能会抛异常，让我们处理起来很麻烦。智能指针放到这样的场景里面就让问题简单多了。
#include<iostream>
using namespace std;
double Divide(int a, int b)
{
// 当b == 0时抛出异常
if (b == 0)
{
throw "Divide by zero condition!";
}
else
{
return (double)a / (double)b;
}
}
void Func()
{
// 这里可以看到如果发生除0错误抛出异常，另外下面的array和array2没有得到释放。
// 所以我们通过捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了先释放空间再重新抛出去。
// 但是如果是 array2 new 的时候抛异常呢(如开的空间过大)，就还需要套一层捕获释放逻辑，
// 但这样实现代码非常的冗余，所以我们有一个更好解决方案——智能指针
int* array1 = new int[10];
int* array2 = new int[100000000000];
//new的空间过大导致抛异常，则就会导致array1的空间还没释放就进行了捕获，从而导致内存泄漏
try
{
int len, time;
cin >> len >> time;
cout << Divide(len, time) << endl;
}
catch (...)
{
cout << "delete []" << array1 << endl;
cout << "delete []" << array2 << endl;
delete[] array1;
delete[] array2;
throw; // 异常重新抛出，捕获到什么抛出什么
}
// ...
cout << "delete []" << array1 << endl;
delete[] array1;
cout << "delete []" << array2 << endl;
delete[] array2;
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch (const exception& e)
{
cout << e.what() << endl;
}
catch (...)
{
cout << "未知异常" << endl;
}
return 0;
}
我们会发现的确打印结果并没有打印 delete，也就说明了 array1 和 array2 的确没有进行释放内存，导致了内存泄漏。那么解决方法也就是上面提到的智能指针了。
2、RAII：智能指针的设计灵魂
- RAII（Resource Acquisition Is Initialization）即 “资源获取立即初始化”，他是一种管理资源的类的设计思想，本质是一种利用对象生命周期来管理获取到的动态资源，避免资源泄露。这里的资源可以是内存，文件指针，网络连接，互斥锁等等。RAII 在获取资源时把资源委托给一个对象，接着控制对资源的访问，资源在对象的生命周期内始终保持有效，最后在对象析构的时候自动释放资源，这样保障了资源的正常释放，避免资源泄露问题。
- 智能指针类除了满足 RAII 的设计思路，还要方便资源的访问，所以智能指针类还会像迭代器类一样，重载 operator* / operator-> / operator[] 等运算符，方便访问资源。
RAII 核心思想：
- 资源（内存、文件句柄、锁）在对象构造时获取；
- 资源在对象生命周期结束时调用析构自动释放（无论正常执行还是异常退出，对象生命周期结束都会调用析构）；
- 智能指针本质是封装了指针的类，重载 *、-> 等运算符，使其模拟指针的行为，同时通过 RAII 管理资源。
简易智能指针实现（理解原理）：
//================================== RAII和智能指针的设计 ==================================
template<class T>
class SmartPtr
{
public:
// RAII
SmartPtr(T* ptr)
:_ptr(ptr)
{
}
~SmartPtr()
{
cout << "delete[] " << _ptr << endl;
delete[] _ptr;
}
// 重载运算符，模拟指针的行为，方便访问资源
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T& operator[](size_t i)
{
return _ptr[i];
}
private:
T* _ptr;
};
double Divide(int a, int b)
{
// 当b == 0时抛出异常
if (b == 0)
{
throw "Divide by zero condition!";
}
else
{
return (double)a / (double)b;
}
}
void Func()
{
// 这里使用RAII的智能指针类管理new出来的数组以后，程序简单多了
SmartPtr<int> sp1 = new int[10];
//SmartPtr<int> sp2 = new int[10];
SmartPtr<int> sp2 = new int[10000000000];
int len, time;
cin >> len >> time;
cout << Divide(len, time) << endl;
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch (const exception& e)
{
cout << e.what() << endl;
}
catch (...)
{
cout << "未知异常" << endl;
}
return 0;
}
这里通过打印的结果我们就看到了当 sp2 new 的空间过大时，就会导致抛异常，但是在跳到 mian函数 捕获异常之前，也就是出函数前 sp1 就会自动调用对应的析构函数进行释放内存，那么也就成功避免了内存泄漏的情况了。
二、C++ 标准库智能指针：使用与原理
C++11 及后续标准提供了 3 种核心智能指针（均在<memory>头文件 中），各自针对不同场景设计，先简单介绍一下，后面逐一详解。
1、三大智能指针的用法及原理
- auto_ptr 是 C++98 时设计出来的智能指针，他的特点是：拷贝时会把拷贝对象的资源的管理权转移给被拷贝对象，这是一个非常糟糕的设计，因为他会导致拷贝对象悬空，访问报错的问题，C++11 设计出新的智能指针后，强烈建议不要使用 auto_ptr。其实 C++11 出来之前很多公司也是明令禁止使用这个智能指针的。
- unique_ptr 是C++11设计出来的智能指针，他的名字翻译出来是唯一指针，他的特点是：不支持拷贝，只支持移动。如果不需要拷贝的场景就非常建议使用 unique_ptr。
- shared_ptr 是C++11设计出来的智能指针，他的名字翻译出来是共享指针，他的特点是：支持拷贝，也支持移动。如果需要拷贝的场景就需要使用shared_ptr 了。底层是通过利用引用计数的方式实现的。
- weak_ptr 是C++11设计出来的智能指针，他的名字翻译出来是弱指针，他是完全不同于上面所提到的智能指针，他不支持 RAII，也就意味着不能用它直接管理资源，weak_ptr 的产生本质是：解决 shared_ptr 的一个循环引用导致内存泄露的问题。
| 智能指针 | 核心特性 | 适用场景 | 效率 | 注意事项 |
|---|---|---|---|---|
| unique_ptr | 独占资源，不支持拷贝 | 局部变量、函数返回值、容器元素 | 最高 | 移动后原对象悬空 |
| shared_ptr | 共享资源，支持拷贝 | 多对象共享资源、多线程共享数据 | 中等 | 避免循环引用（用 weak_ptr 解决） |
| weak_ptr | 弱引用，不管理资源 | 解决 shared_ptr 循环引用、观察资源 | 高 | 需 lock() 获取 shared_ptr 才能访问资源 |
1.1 auto_ptr 的模拟实现(了解即可)
由于 auto_ptr 一般我们不会进行使用，所以这里就简单模拟实现一下，了解即可，这里所实现的 Date 类在后续的智能指针模拟实现还会使用，后续就不再重复展示了：
//================================== auto_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;
}
};
namespace xiaoye
{
template<class T>
class auto_ptr
{
public:
auto_ptr(T* ptr)
:_ptr(ptr)
{
}
//auto_ptr拷贝构造
auto_ptr(auto_ptr<T>& sp)
:_ptr(sp._ptr)
{
// 管理权转移
sp._ptr = nullptr;
}
//auto_ptr赋值重载
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;
};
}
int main()
{
xiaoye::auto_ptr<Date> ap1(new Date);
// 拷贝时，管理权限转移，被拷贝对象ap1悬空
xiaoye::auto_ptr<Date> ap2(ap1);
// 空指针访问，ap1对象已经悬空
ap1->_year++;
return 0;
}
1.2 unique_ptr：独占式智能指针（推荐优先使用）
unique_ptr 意为 “唯一指针”，核心特性：资源独占，不支持拷贝，仅支持移动，效率最高（无引用计数开销）。
核心用法：
//================================== unique_ptr 的使用 ==================================
int main()
{
// 构造：托管资源
std::unique_ptr<Date> up1(new Date(2024, 10, 1));
// 支持指针操作
up1->_year = 2025;
cout << up1->_year << endl;
// 不支持拷贝（编译报错）
//unique_ptr<Date> up2(up1); //error
// 支持移动（资源所有权转移，up1悬空，谨慎使用）
unique_ptr<Date> up3(move(up1));
if (!up1) cout << "up1已悬空" << endl;
// 管理数组（特化版本，析构时用delete[]）
unique_ptr<Date[]> up4(new Date[5]);
return 0;
}
适用场景：
- 局部变量、函数返回值（无需共享资源）；
- 容器元素（避免拷贝开销）；
- 替代 auto_ptr（auto_ptr 拷贝时转移所有权，易导致悬空指针，已被废弃）。
unique_ptr 的模拟实现(也是了解即可)：
//================================== unique_ptr 的简单模拟实现 ==================================
namespace xiaoye
{
template<class T>
class unique_ptr
{
public:
explicit unique_ptr(T* ptr)
:_ptr(ptr)
{
}
~unique_ptr()
{
if (_ptr)
{
cout << "delete:" << _ptr << endl;
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;
unique_ptr(unique_ptr<T>&& sp)
:_ptr(sp._ptr)
{
sp._ptr = nullptr;
}
unique_ptr<T>& operator=(unique_ptr<T>&& sp)
{
delete _ptr;
_ptr = sp._ptr;
sp._ptr = nullptr;
return *this;
}
private:
T* _ptr;
};
}
int main()
{
xiaoye::unique_ptr<Date> up1(new Date);
// 不支持拷贝
//unique_ptr<Date> up2(up1);
// 支持移动，但是移动后up1也悬空，所以使用移动要自我谨慎
xiaoye::unique_ptr<Date> up3(move(up1));
//up1->_year++;
return 0;
}
1.3 shared_ptr：共享式智能指针（支持拷贝，重点了解）
shared_ptr 意为 “共享指针”，核心特性：支持拷贝和移动，通过引用计数管理资源，多个shared_ptr 可托管同一资源，引用计数为 0 时自动释放。
核心原理：
- 引用计数：堆上维护一个计数器，记录当前托管该资源的 shared_ptr 数量；
- 构造 / 拷贝：计数器 + 1；
- 析构：计数器 - 1，计数器为 0 时释放资源。
核心用法：
//================================== shared_ptr 的使用 ==================================
int main()
{
// 构造：托管资源，计数器初始为1
std::shared_ptr<Date> sp1(new Date(2024, 10, 1));
cout << "sp1引用计数：" << sp1.use_count() << endl; // 输出1
// 拷贝：计数器+1
std::shared_ptr<Date> sp2(sp1);
std::shared_ptr<Date> sp3 = sp2;
cout << "sp1引用计数：" << sp1.use_count() << endl; // 输出3
// 移动：所有权转移，原对象悬空，计数器不变
std::shared_ptr<Date> sp4(move(sp1));
cout << "sp1是否为空：" << (sp1 ? false : true) << endl; // 输出true
cout << "sp1引用计数：" << sp1.use_count() << endl; // 输出0
cout << "sp4引用计数：" << sp4.use_count() << endl; // 输出3
// 管理数组（特化版本）
std::shared_ptr<Date[]> sp5(new Date[5]);
// 推荐：用make_shared构造（更高效，避免内存泄漏风险）
auto sp6 = make_shared<Date>(2024, 10, 2);
return 0;
}
适用场景：
- 资源需要被多个对象共享（如容器中存储的对象、多线程共享数据）；
- 无法确定哪个对象最后释放资源的场景。
shared_ptr 的模拟实现(需重点掌握，面试也会要求手撕)：
大家重点需要看一下 shared_ptr 是如何设计的，尤其是引用计数的设计，主要这里一份资源就需要一个引用计数，所以引用计数使用静态成员的方式是无法实现的，要使用堆上动态开辟的方式，构造智能指针对象时来一份资源，就要new一个引用计数出来。多个 shared_ptr 指向同一份资源时就 ++引用计数，shared_ptr 对象析构时就 --引用计数，当引用计数减到0时代表当前析构的shared_ptr 是最后一个管理资源的对象，则析构资源。
//================================== shared_ptr 的简单模拟实现 ==================================
namespace xiaoye
{
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr)
, _pcount(new int(1))
{
}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pcount(sp._pcount)
//地址拷贝，使得地址相同满足共享要求
{
++(*_pcount);
}
~shared_ptr()
{
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
}
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
////错误版本：
//if (--(*_pcount) == 0)
//{
// delete _ptr;
// delete _pcount;
//}
////上面这个代码是非常容易被忽视的，但却是极其重要，一定要想清楚
////对于同一块空间资源如果有多个对象共享倒不会出现什么问题，
////比如sp1 = sp2、sp3 = sp3(sp3所对于的空间资源不止一个对象)，这样if语句就不会执行
////但是如果是类似sp4 = sp4，且只有sp4一个对象占据一块空间资源
////就会导致--(*_pcount)为0进入if语句，从而导致进行自我delete
////解决方法就是判断拷贝赋值两边是否是同一个对象即可，如果是则无需进行赋值
//_ptr = sp._ptr;
//_pcount = sp._pcount;
//++(*_pcount);
//return *this
////优化版本一：
//if (this != &sp)
//{
// if (--(*_pcount) == 0)
// {
// delete _ptr;
// delete _pcount;
// }
// _ptr = sp._ptr;
// _pcount = sp._pcount;
// ++(*_pcount);
//}
////这样就可以解决自己给自己赋值，且只有自己占据一块空间资源的情况
////但是这种优化其实还不够，因为我们知道如果是共享同一块空间资源的两个对象赋值也没有意义
////虽然不会释放空间，但是赋值了也是做无用功，所以这种情况也可以不进行赋值
//return *this
//最终优化：
if (this->_ptr != sp._ptr)
{
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
}
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
}
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
int* _pcount;
};
}
int main()
{
xiaoye::shared_ptr<Date> sp1(new Date);
// 支持拷贝
xiaoye::shared_ptr<Date> sp2(sp1);
xiaoye::shared_ptr<Date> sp3(sp2);
sp1->_year++;
cout << sp1->_year << endl;
cout << sp2->_year << endl;
cout << sp3->_year << endl;
xiaoye::shared_ptr<Date> sp4(new Date);
//sp1 = sp4;
sp4 = sp4;
return 0;
}
1.4 weak_ptr：弱引用智能指针（解决循环引用）
weak_ptr 是为解决shared_ptr的循环引用问题而生。
核心特性：
- 不支持 RAII，不能直接托管资源；
- 仅能从 shared_ptr 构造，绑定后不增加引用计数；
- 不重载 *、->，需通过 lock() 获取 shared_ptr 才能访问资源；
- 支持 expired() 判断资源是否已释放。
核心用法：
//============================== weak_ptr 的使用 ==============================
int main()
{
std::shared_ptr<string> sp1(new string("111111"));
std::shared_ptr<string> sp2(sp1);
std::weak_ptr<string> wp = sp1;
cout << wp.expired() << endl;
cout << wp.use_count() << endl;
//weak_ptr绑定shared_ptr时，不会增加shared_ptr的引用计数，此时引用计数仍是2
// sp1和sp2都指向了其他资源，则weak_ptr就过期了
sp1 = make_shared<string>("222222");
cout << wp.expired() << endl;
cout << wp.use_count() << endl;
sp2 = make_shared<string>("333333");
cout << wp.expired() << endl;//此时p1和sp2都已经指向了其他资源，则wp指向的资源已经过期了，expired返回1
cout << wp.use_count() << endl;
cout << "***************************************" << endl;
wp = sp1;
//std::shared_ptr<string> sp3 = wp.lock();
auto sp3 = wp.lock();
//weak_ptr 通过调用lock()就可以自己给自己加引用计数
//本质是：lock可以返回一个管理资源的 shared_ptr
cout << wp.expired() << endl;
cout << wp.use_count() << endl;
sp1 = make_shared<string>("444444");//此时sp1再次指向其他资源，wp所指向的资源也不会过期了，有sp3在
cout << wp.expired() << endl;
cout << wp.use_count() << endl;
return 0;
}
weak_ptr 的模拟实现(也是了解即可)：
//============================== weak_ptr 的模拟实现 ==============================
namespace xiaoye
{
template<class T>
class weak_ptr
{
public:
weak_ptr()
{
}
weak_ptr(const shared_ptr<T>& sp)
:_ptr(sp.get())
{
}
// 不参与资源的管理
private:
T* _ptr = nullptr;
// int* _pcount;
};
}1.4.1 循环引用问题（shared_ptr 的致命缺陷）
分析：
//============================== 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);
std::shared_ptr<ListNode> n2(new ListNode);
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
//由于n1、n2的类型是shared_ptr的智能指针，而如果其成员变量_next、_prev仍是ListNode*类型
//则类型无法匹配导致无法进行连接，所以我们需要将_next、_prev类型也修改为shared_ptr，则循环引用的问题也随之出现了
n1->_next = n2;
n2->_prev = n1;
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
return 0;
}用 weak_ptr 解决循环引用
将互相引用的成员改为 weak_ptr，正是利用 weak_ptr 不参与引用计数管理这个特性，当 n1->_next 与 n2 连接 以及 n2->_prev 与 n1 连接时，就不会增加引用计数了，打破循环：
//============================== weak_ptr 解决循环引用 ==============================
struct ListNode
{
int _data;
// 这里改成weak_ptr，当 n1->_next = n2; 绑定 shared_ptr 时不增加 n2 的引用计数，
//不参与资源释放的管理，就不会形成循环引用了
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);
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
n1->_next = n2;
n2->_prev = n1;
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
// weak_pt不支持管理资源，不支持RAII
// weak_ptr是专门绑定 shared_ptr，不增加他的引用计数，作为⼀些场景的辅助管理
//std::weak_ptr<ListNode> wp(new ListNode);
return 0;
}
2、定制删除器（管理非 new 资源）
2.1 定制删除器的使用
智能指针默认用 delete 释放资源，若托管的是 new[]、文件句柄、锁等资源，需定制删除器（本质是可调用对象：仿函数、函数指针、lambda）。
//============================== shared_ptr 和 unique_ptr 定制删除器的使用 ==============================
//仿函数实现定制删除器
struct Fclose
{
void operator()(FILE* ptr)
{
cout << "fclose：" << ptr << endl;
fclose(ptr);
}
};
//函数指针实现定制删除器
template<class T>
void DeleteFile(T* ptr)
{
cout << "fclose：" << ptr << endl;
fclose(ptr);
}
//对于上面shared_ptr的简单实现会发现我们都是new一个Date空间
//那如果我们要new一个Date的数组呢(new Date[])，按照上面的实现还可行吗？
int main()
{
//std::shared_ptr<Date> sp1(new Date[5]); //error
//不管是上面我们的模拟实现还是std里面的都不可行，原因就在于：
//shared_ptr的模板参数传Date时，对应的析构为：delete _ptr，而不是delete[] _ptr
//在之前的学习中我们讲过 new一个空间 和 new一段空间 所对应的delete是不同的，
//new一个空间对应的销毁是delete；new一段空间对应的销毁是delete[]。不能交叉使用否则就会程序崩溃
//那如何解决new一段空间的情况呢？标准库的shared_ptr针对 new[] 给了一个特化版本：
std::shared_ptr<Date[]> sp1(new Date[5]); //之所以给这么一个特化版本就是因为平常使用new[]还是比较频繁的
//那如果也不是new[]，而是类似fopen这种情况呢？
//因为标准库的shared_ptr只是针对 new[] 给的特化版本，而这种情况就需要借助定制删除器了
//template <class U, class D> shared_ptr (U* p, D del);
//删除器本质其实就是一个可调用对象(包含了lambda表达式、函数指针、仿函数等)
//析构的时候就是类似：del(_ptr)
//仿函数的删除器
std::shared_ptr<FILE> sp2(fopen("Test.cpp", "r"), Fclose());
//lambda表达式的删除器(最推荐使用，更加简洁)
std::shared_ptr<FILE> sp3(fopen("Test.cpp", "r"), [](FILE* ptr) {
cout << "fclose：" << ptr << endl;
fclose(ptr);
});
//函数指针的删除器
std::shared_ptr<FILE> sp4(fopen("Test.cpp", "r"), DeleteFile<FILE>);
//**************************************************************************************
//而对于unique_ptr的删除器使用和shared_ptr是有很大差别的，原因在于他们的结构不同
//shared_ptr是只在构造中添加删除器的模板参数，而unique_ptr是在整个类中添加，这就会导致在使用上非常的麻烦
//template <class T, class D = default_delete<T>> class unique_ptr;
//unique_ptr的删除器，建议使用仿函数
std::unique_ptr<FILE, Fclose> sp5(fopen("Test.cpp", "r"));
//对于仿函数的删除器，在使用上和shared_ptr多大差别的，
//也就是shared_ptr需要传一个仿函数对象Fclose()，而unique_ptr是要传一个类型Fclose
//std::unique_ptr<FILE, [](FILE* ptr){ fclose(ptr); }> sp5(fopen("Test.cpp", "r"));//error
//但是对于lambda表达式而言就不行了，因为前面我们学习了lambda表达式在语法层上是没有类型的
//而unique_ptr我们是需要传入类型，之所以shared_ptr可行是因为构造中的传的del是一个可调用对象，而不是一个类型
//我们传入lambda表达式模板参数D会自动推导lambda类型，而unique_ptr只能传入类型
//这里我直接把lambda表达式作为删除器的写法展示出来，大家了解即可，非常的麻烦不要使用
auto fclosefunc = [](FILE* ptr) { fclose(ptr); };
std::unique_ptr < FILE, decltype(fclosefunc) > sp6(fopen("Test.cpp", "r"), fclosefunc);
return 0;
}2.2 定制删除器的模拟实现
//============================== shared_ptr 定制删除器的模拟实现 ==============================
#include<functional>
namespace xiaoye
{
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr)
, _pcount(new int(1))
{
}
//模拟实现删除器时有个比较坑的点在于：
//含删除器的shared_ptr构造，因为模板参数只针对构造函数，所以无法在类中直接定义_del的类型
//但由于删除器本质就是一个可调用对象，所以可以利用function进行包装
template<class D>
shared_ptr(T* ptr, D del)
:_ptr(ptr)
, _pcount(new int(1))
, _del(del)
{
}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pcount(sp._pcount)
//地址拷贝，使得地址相同满足共享要求
{
++(*_pcount);
}
~shared_ptr()
{
if (--(*_pcount) == 0)
{
//delete _ptr;
_del(_ptr);
//删除器_del释放_ptr
delete _pcount;
}
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
if (this->_ptr != sp._ptr)
{
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
}
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
}
return *this;
}
int& use_count()
{
return *_pcount;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
int* _pcount;
//D _del; //因为shared_ptr删除器是针对构造函数的，模板参数无法代表整个类
//那么我们怎么定义_del呢？还是回顾一下之前C++11的学习，
//因为删除器本质是一个可调用对象，那么对于可调用对象的类型我们是不是就可以利用function来包装
function<void(T*)> _del = [](T* ptr) {delete ptr; };
//这里一定要清楚function的模板参数为什么是void(T*)：
//因为删除器的作用就是释放空间，所以是没有返回类型的 -> void
//而删除器释放的对象就是_ptr，_ptr的类型为T*，所以参数列表传的就是T*
//但如果创建的智能指针只是new出来的而非需要删除器，
//那么析构就期望是delete，则可以给一个labmda的缺省值进行实现
};
}
int main()
{
//删除器的模拟实现
xiaoye::shared_ptr<Date> sp1(new Date);
xiaoye::shared_ptr<Date> sp2(new Date[5], [](Date* ptr) { delete[] ptr; });
return 0;
3、补充知识
int main()
{
//make_shared的使用
//shared_ptr 支持 make_shared 用初始化资源对象的值直接构造
std::shared_ptr<Date> sp3(new Date(2024, 9, 11));
std::shared_ptr<Date> sp4 = make_shared<Date>(2024, 9, 11);
auto sp5 = make_shared<Date>(2024, 9, 11);
//operator bool的类型转换
//智能指针对象是一个空对象没有管理资源，则返回false，否则返回true
shared_ptr<Date> sp6;
// if (sp1.operator bool())
if (sp3)
cout << "sp1 is not nullptr" << endl;
if (!sp6)
cout << "sp1 is nullptr" << endl;
//shared_ptr和unique_ptr构造函数用explicit修饰
//目的是：防止普通指针隐式类型转换成智能指针对象
// 报错
/*shared_ptr<Date> sp5 = new Date(2024, 9, 11);
unique_ptr<Date> sp6 = new Date(2024, 9, 11);*/
return 0;
}
三、shared_ptr 的线程安全问题
前置说明：【shared_ptr的线程安全问题】这个模块可以在 Linux学完【多线程】之后再来看，就很明白了
- shared_ptr 的引用计数对象在堆上,如果多个 shared_ptr 对象在多个线程中，进行 shared_ptr的拷贝析构时会访问修改引用计数，就会存在线程安全问题。所以shared_ptr引用计数是需要加锁或者原子操作保证线程安全的。
- shared_ptr 指向的对象也是有线程安全问题的，但是这个对象的线程安全问题不归shared_ptr管，它也管不了，应该有外层使用 shared_ptr 的人进行线程安全的控制。
- 下面的程序会崩溃或者A资源没释放， xiaoye::shared_ptr 引用计数从 int* 改成 atomic<int>* 就可以保证引用计数的线程安全问题，或者使用互斥锁加锁也可以。
//============================== shared_ptr 的线程安全问题 ==============================
#include<thread>
#include<mutex>
#include<atomic>
namespace xiaoye
{
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr)
, _pcount(new atomic<int>(1))
{
}
template<class D>
shared_ptr(T* ptr, D del)
: _ptr(ptr)
, _pcount(new atomic<int>(1))
, _del(del)
{
}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pcount(sp._pcount)
{
++(*_pcount);
}
~shared_ptr()
{
if (--(*_pcount) == 0)
{
_del(_ptr);
delete _pcount;
}
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
if (this->_ptr != sp._ptr)
{
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
}
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
}
return *this;
}
atomic<int>& use_count()
{
return *_pcount;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
//int* _pcount;
atomic<int>* _pcount;
function<void(T*)> _del = [](T* ptr) {delete ptr; };
};
}
struct AA
{
int _a1 = 0;
int _a2 = 0;
~AA()
{
cout << "~AA()" << endl;
}
};
int main()
{
xiaoye::shared_ptr<AA> p(new AA);
const size_t n = 100000;
mutex mtx;
auto func = [&]()
{
for (size_t i = 0; i < n; ++i)
{
// 这里智能指针拷贝会++计数
xiaoye::shared_ptr<AA> copy(p);
{
unique_lock<mutex> lk(mtx);
copy->_a1++;
copy->_a2++;
}
}
};
thread t1(func);
thread t2(func);
t1.join();
t2.join();
cout << p->_a1 << endl;
cout << p->_a2 << endl;
cout << p.use_count() << endl;
//输出：
//20
//20
//1
//~AA()
return 0;
}四、C++11和boost中智能指针的关系
- Boost库是为C++标准库提供扩展的一些C++程序库的总称，Boost社区建议的初衷之一就是为C++的标准化工作提供可参考的实现，Boost社区的发起人Dawes本人就是C++标准委员会的成员之⼀。在Boost库的开发中，Boost社区也在这个方向上取得了丰硕的成果，C++11及之后的新语法和库有很多都是从Boost中来的。
- C++ 98 中产生了第⼀个智能指针auto_ptr。
- C++ boost给出了更实用的scoped_ptr/scoped_array和shared_ptr/shared_array和weak_ptr等。
- C++ TR1，引入了shared_ptr等，不过注意的是TR1并不是标准版。
- C++ 11，引⼊了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的 scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。
五、内存泄漏：大型项目设计必备
1、什么是内存泄漏，内存泄漏的危害
- 什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存，一般是忘记释放或者发生异常释放程序未能执行导致的。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对改段内存的控制，因而造成了内存的浪费。
- 内存泄漏的危害：普通程序运行一会就结束了出现内存泄漏问题也不大，进程正常结束，页表的映射关系解除，物理内存也可以释放。长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务、长时间运行的客户端等等，不断出现内存泄漏会导致可用内存不断变少，各种功能响应越来越慢，最终卡死。
2、如果检查内存泄露(了解)
- Linux 下内存泄露检测：
- Windows 下使用第三方工具：
3、如何避免内存泄漏
- 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps: 这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一个智能指针来管理才有保证。
- 尽量使用智能指针来管理资源，如果自己面临的场景比较特殊，采用RAII思想自己造个轮子管理。
- 定期使用内存泄露工具检测，尤其是项目上线之前，不过有些工具不台靠谱，或者是要收费。
- 总结一下：内存泄露非常常见，解决方案无非就是两种：1. 事前预防型。如智能指针等。2. 事后查错型。如泄漏检测工具。
结束语
到此，C++的智能指针就全部讲解完了。智能指针是 C++ 中解决内存泄漏的 “终极武器”，掌握其 RAII 设计思想、三种核心指针的用法与场景，能让你的代码更安全、更易维护。实际开发中，优先使用unique_ptr（高效无开销），需要共享资源时用shared_ptr，遇到循环引用时用weak_ptr配合，再结合定制删除器处理特殊资源，即可覆盖绝大多数场景。
而到这里我们C++的主线也就彻底完结了，再次非常感谢大家的支持，这是结束但也是新的开始，在后面我就会开始为大家讲解 Linux 的知识。
希望对大家学习C++能有所收获！
C++参考文档：
https://legacy.cplusplus.com/reference/
https://zh.cppreference.com/w/cpp
https://en.cppreference.com/w/
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
39
0- 0
已为社区贡献7条内容
所有评论(0)