目录
[1 智能指针的使用场景分析](#1 智能指针的使用场景分析)
[2 RAII和智能指针的设计思路](#2 RAII和智能指针的设计思路)
[3 C++标准库智能指针的使用](#3 C++标准库智能指针的使用)
[4 智能指针的原理](#4 智能指针的原理)
[5 shared_ptr和weak_ptr](#5 shared_ptr和weak_ptr)
[5.1 shared_ptr循环引用问题](#5.1 shared_ptr循环引用问题)
[5.2 weak_ptr](#5.2 weak_ptr)
[6 内存泄漏](#6 内存泄漏)
[6.1 什么是内存泄漏，内存泄漏的危害](#6.1 什么是内存泄漏，内存泄漏的危害)
[6.2 如何避免内存泄漏](#6.2 如何避免内存泄漏)
1 智能指针的使用场景分析
在写程序时，有时new了之后，也delete了，但是有时因为抛异常的存在，可能后面的delete没有执行，这样就会内存泄漏，所以需要new以后捕获异常，捕获异常后delete内存，再把内存抛出。
这里有一个这样的例子：
cpp
class Exception
{
public:
Exception(const string& errmsg, int id)
:_errmsg(errmsg)
, _id(id)
{}
virtual string what() const
{
return _errmsg;
}
int getid() const
{
return _id;
}
protected:
string _errmsg;
int _id;
};
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没有得到释放
//所以这里捕获异常后不处理异常，异常还是交给外面处理，这里捕获了再重新抛出去
int* array1 = new int[10];
int* array2 = new int[10];
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;
cout << "delete[]" << array2 << endl;
delete[] array1;
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;
}上面的程序如果array2 new的时候抛异常的话，就还需要套一层捕获逻辑释放，这样很麻烦，所以这时候用智能指针更好，问题就会简单很多。
2 RAII和智能指针的设计思路
RAII（Resource Acquisition Is Initialization，资源获取即初始化），是C++最重要的设计理念之一。它利用对象的生命周期来管理资源。
基本原则有：
- 资源的所有权与对象生命周期绑定
- 对象创建时获取资源
- 对象销毁时自动释放资源
- 异常安全的重要保障
智能指针类满足RAII的设计思路，同时也方便资源的访问，像迭代器类一样重载了operator*/operator->/operator[]等运算符，方便访问资源。
cpp
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];
for (size_t i = 0; i < 10; i++)
{
sp1[i] = sp2[i] = i;
}
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;
}在传统的C语言风格这就要求程序员必中，内存管理遵循一个看似简单的模式：谁申请，谁释放。须对每一份通过new或malloc获得的资源在合适的时机用delete或free释放。这是一项高风险的约定。
RAII（资源获取即初始化）提出了一种范式转移：
不要让人去追踪资源的生命周期，而将资源绑定到具有明确、自动生命周期的对象上。
智能指针就是利用了这一思想，上述程序中sp1和sp2因为任何原因离开作用域时，它们的析构函数都会无条件的自动调用。
3 C++标准库智能指针的使用
C++标准库中的智能指针都在<memory>这个头文件下面。智能指针有好几种，原理上而言主要是解决智能指针拷贝时的思路不同。
auto_ptr是C++98设计出来的智能指针，特点是拷贝时把被拷贝对象的资源管理权转移给拷贝对象，被拷贝对象会悬空，访问被拷贝对象会报错，这样很危险。所以auto_ptr被很多公司禁止使用。
unique_ptr是C++11设计出来的智能指针，它的特点是不支持拷贝，只支持移动。如果不需要拷贝的场景建议使用它。
shared_ptr是C++11设计出来的智能指针，它的特点是支持拷贝，也支持移动。如果需要拷贝的场景就需要使用它。
weak_ptr是C++11设计出来的智能指针，它不同于上面的智能指针，它不支持RAII，也就意味着不能用它直接管理资源，weak_ptr的产生本质是要解决shared_ptr的一个循环引用导致内存泄露的问题。
cpp
struct Date
{
int _year;
int _month;
int _day;
Date(int year=2026,int month=1,int day=8)
:_year(year)
,_month(month)
,_day(day)
{ }
~Date()
{
cout << "~Date()" << endl;
}
};
int main()
{
auto_ptr<Date> ap1(new Date);
//拷贝时，管理权限转移，被拷贝对象悬空，危险,再访问就是空指针访问
auto_ptr<Date> ap2(ap1);
unique_ptr<Date> up1(new Date);
//不支持拷贝
//unique_ptr<Date> up2(up1);
//支持移动，但是移动后up1也悬空，所以谨慎使用
unique_ptr<Date> up3(move(up1));
shared_ptr<Date> sp1(new Date);
//支持拷贝
shared_ptr<Date> sp2(sp1);
shared_ptr<Date> sp3(sp2);
cout << sp1.use_count() << endl;
sp1->_year++;
cout << sp1->_year << endl;
cout << sp2->_year << endl;
cout << sp3->_year << endl;
//支持移动，但是移动后sp1也悬空，使用移动要谨慎
shared_ptr<Date> sp4(move(sp1));
return 0;
}智能指针析构时默认是进行delete释放资源，也就意味着如果不是new出来的资源，交给智能指针管理，析构时就会崩溃。所以智能指针支持在构造时给一个删除器，删除器的本质就是一个可调用对象，这个可调用对象中实现想要的释放资源的方式，当构造智能指针时，给了定制的删除器，在智能指针析构时就会调用删除器去释放资源。
因为new[]经常使用，所以unique_ptr和shared_ptr实现了一个特化版本，这个特化版本析构时用delete[]
cpp
template<class T>
void DeleteArrayFunc(T* ptr)
{
delete[] ptr;
}
template<class T>
class DeleteArray
{
public:
void operator()(T* ptr)
{
delete[] ptr;
}
};
class Fclose
{
public:
void operator()(FILE* ptr)
{
cout << "fclose:" << ptr << endl;
fclose(ptr);
}
};
int main()
{
//这样实现程序或崩溃
//unique_ptr<Date> up1(new Date[10]);
//shared_ptr<Date> sp1(new Date[10]);
//解决方案1
//因为new[]经常使用，所以unique_ptr和shared_ptr实现了一个特化版本，这个特化版本析构时用delete[]
unique_ptr<Date[]> up1(new Date[10]);
shared_ptr<Date[]> sp1(new Date[10]);
//解决方案2
//仿函数对象做删除器
//unique_ptr和shared_ptr支持的删除器的方式有所不同
//unique_ptr是在类模板参数支持的，shared_ptr是构造函数参数支持的
//这里没有统一是一个坑
//使用仿函数unique_ptr可以不在构造函数传递，因为仿函数类型构造的对象直接就可以调用
//但是下面的函数指针和lambda的类型就不可以
unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);
shared_ptr<Date> sp2(new Date[5], DeleteArray<Date>());
//函数指针做删除器
unique_ptr<Date, void(*)(Date*)> up3(new Date[5], DeleteArrayFunc<Date>);
shared_ptr<Date> sp3(new Date[5], DeleteArrayFunc<Date>);
//lambda表达式做删除器
auto delArrOBJ = [](Date* ptr) {delete[] ptr; };
unique_ptr<Date, decltype(delArrOBJ)> up4(new Date[5], delArrOBJ);
shared_ptr<Date> sp4(new Date[5], delArrOBJ);
//实现其他资源管理的删除器
shared_ptr<FILE> sp5(fopen("test.cpp", "r"), Fclose());
shared_ptr<FILE> sp6(fopen("Test.cpp", "r"), [](FILE* ptr) {
cout << "fclose:" << ptr << endl;
fclose(ptr);
});
return 0;
}shared_ptr除了支持用指向资源的指针构造，还支持make_shared用初始化资源对象的值直接构造。
shared_ptr和unique_ptr都支持了operator bool的类型转换，如果智能指针对象是一个空对象没有管理资源，则返回false，否则返回true，意味着可以直接把智能指针对象给if判断是否为空。
shared_ptr和unique_ptr得构造函数都使用explicit修饰，防止普通指针隐式类型转换成智能指针对象。
cpp
int main()
{
shared_ptr<Date> sp1(new Date(2026, 1, 1));
shared_ptr<Date> sp2 = make_shared<Date>(2026, 1, 1);
auto sp3 = make_shared<Date>(2026, 1, 1);
shared_ptr<Date> sp4;
// if (sp1.operator bool())
if (sp1)
cout << "sp1 is not nullptr" << endl;
if (!sp4)
cout << "sp1 is nullptr" << endl;
// 报错
//shared_ptr<Date> sp5 = new Date(2026, 1, 1);
//unique_ptr<Date> sp6 = new Date(2026, 1, 1);
return 0;
}为什么两行代码会报错？根本原因是智能指针的构造函数是explicit的。explicit关键字意味着禁止隐式类型转换。
为什么使用explicit?
一是防止意外所有权转移：
cpp
// 假设允许隐式转换，危险场景：
void process(shared_ptr<Date> sp) {
//这个函数获得指针所有权
}
Date* raw_ptr = new Date(2026, 1, 1);
process(raw_ptr); // 如果允许隐式转换，这里会转移所有权
// 现在 raw_ptr 指向的内存可能已被释放，但 raw_ptr 还是野指针二是避免双重释放：
cpp
// 危险代码示例，如果允许隐式转换
Date* p = new Date(2026, 1, 1);
{
shared_ptr<Date> sp1 = p; // sp1 获得所有权
} // sp1 析构，释放 p
shared_ptr<Date> sp2 = p; // sp2 又获得同一个指针
// 双重释放，程序崩溃所以推荐使用make_shared：
cpp
// 更安全、更高效的方式
shared_ptr<Date> sp5 = make_shared<Date>(2026, 1, 1); 没有explicit的危险：
cpp
// 假设 shared_ptr 构造函数不是 explicit
void func1(shared_ptr<Date> sp); // 接受 shared_ptr
void func2(Date* p); // 接受原生指针
Date* p = new Date(2026, 1, 1);
func1(p); // 如果允许隐式转换，编译器会：
// 1. 创建临时 shared_ptr(p)
// 2. func1 结束后临时对象析构，释放 p
// 3. p 变成野指针
func2(p); // 使用野指针，未定义行为使用explicit进行保护：
cpp
// 实际：构造函数是 explicit
func1(p); // 编译错误：不能隐式转换
func1(shared_ptr<Date>(p)); // 必须显式构造
// 这样明确知道所有权转移
shared_ptr<Date> sp(p); // 明确：p 的所有权给了 sp
func1(sp); // 安全：共享所有权所以记住这个规则：
4 智能指针的原理
这里重点掌握shared_ptr是如何设计的，这里是依据引用计数设计的。一份资源就需要一个引用计数。所以引用计数用静态成员的方式是无法实现的，要使用堆上动态开辟的方式，构造智能指针对象时来一份资源，就要new一个引用计数出来。多个shared _ptr指向资源时就++引用计数，shared_ptr对象析构时就--引用计数，引用计数减到0时代表当前析构的shared_ptr是最后一个管理资源的对象，则析构资源。
shared_ptr模拟实现：
cpp
namespace as
{
template <class T>
class shared_ptr
{
public:
explicit shared_ptr(T* ptr=nullptr)
:_ptr(ptr)
,_pcount(new int(1))
{ }
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)
,_del(sp._del)
{
++(*_pcount);
}
void release()
{
if (--(*_pcount) == 0)
{
//最后一个管理的对象，释放资源
_del(_ptr);
delete _pcount;
_ptr = nullptr;
_pcount = nullptr;
}
}
~shared_ptr()
{
release();
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
if (_ptr != sp._ptr)
{
release();//避免自赋值，释放旧资源
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
_del = sp._del;
}
return *this;
}
T* get() const
{
return _ptr;
}
int use_count() const
{
return *_pcount;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
int* _pcount;
function<void(T*)> _del = [](T* ptr) {delete ptr; };
};
template<class T>
class weak_ptr
{
public:
weak_ptr()
{ }
weak_ptr(const shared_ptr<T>& sp)
:_ptr(sp.get())
{ }
weak_ptr<T>& operator=(const shared_ptr<T>& sp)
{
_ptr = sp.get();
return *this;
}
private:
T* _ptr = nullptr;
};
}5 shared_ptr和weak_ptr
5.1 shared_ptr循环引用问题
shared_ptr大多数情况下管理资源非常合适，支持RAII，也支持拷贝。但是在循环利用的场景下会导致资源没得到释放内存泄漏，所以我们要认识循环引用的场景和没释放的原因，并且利用weak_ptr解决这种问题。
如下图所述场景，n1和n2析构后，管理两个节点的引用计数减到1。
右边的节点释放的条件是_next析构后，右边的节点释放；_next析构时的条件是左边的节点释放，_next就释放了；左边的节点释放的条件是_prev析构后，左边的节点释放；_prev析构的条件是右边的节点释放，_prev释放。
这样就导致逻辑闭环了，这都不会释放就形成了循环引用，导致内存泄漏。
把ListNode结构体中的_next和_prev改成weak_ptr，weak_ptr绑定到shared_ptr时不会增加它的引用计数，_next和_prev不参与资源释放管理逻辑，就成功打破了循环引用，解决了这里的问题。
cpp
struct ListNode
{
int _data;
std::shared_ptr<ListNode> _next;
std::shared_ptr<ListNode> _prev;
//这里用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_ptr不支持管理资源，不支持RAII
//weak_ptr是专门绑定shared_ptr,不增加他的引用计数，作为一些场景的辅助管理
//std::weak_ptr<ListNode> wp(new ListNode);
return 0;
}5.2 weak_ptr
weak_ptr不支持RAII，也不支持访问资源，所以看文档会发现weak_ptr构造时不支持绑定到资源，只支持绑定到shared_ptr，绑定到shared_ptr时，不增加shared_ptr的引用计数，那么就可以解决上述的循环引用问题。
weak_ptr也没有重载operator*和operator->等，因为他不参与资源管理，那么如果它不参与资源管理，如果它绑定的shared_ptr已经释放了资源，那么它去访问资源就是很危险的。weak_ptr支持expired检查指向的资源是否过期，use_count也可获取shared_ptr的引用计数，weak_ptr想访问资源时，可以调用lock返回一个管理资源的shared_ptr，如果资源已经释放，返回的shared_ptr是一个空对象，如果资源没有释放，则通过返回的shared_ptr访问资源是安全的。
cpp
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;
// 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;
cout << wp.use_count() << endl;
wp = sp1;
//std::shared_ptr<string> sp3 = wp.lock();
auto sp3 = wp.lock();
cout << wp.expired() << endl;
cout << wp.use_count() << endl;
*sp3 += "###";
cout << *sp1 << endl;
return 0;
}6 内存泄漏
6.1 什么是内存泄漏，内存泄漏的危害
内存泄漏 是指程序在动态分配内存后，失去了对该内存区域的引用，导致这块内存既无法被程序使用，也无法被操作系统回收，成为"孤儿内存"。
内存泄漏的危害：普通程序运⾏⼀会就结束了出现内存泄漏问题也不大，进程正常结束，页表的映射关系解除，物理内存也可以释放。长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务、长时间运行的客户端等等，不断出现内存泄漏会导致可⽤内存不断变少，各种功能响应越来越慢，最终卡死。
6.2 如何避免内存泄漏
- ⼯程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。
- 尽量使用智能指针来管理资源，如果自己场景比较特殊，采用RAII思想自己造个轮子管理。
- 定期使用内存泄漏工具检测。
以上就是本文的全部内容了，如果这篇文章对你有用，可以点点赞哦，你的支持就是我写下去的动力，后续会不断地更新知识。