👋 欢迎阅读

🔥愿旖旎 · 个人主页
📘学习专栏: 《算法专栏》《LangChain学习》《贪心算法》
🌄 钱塘江上潮信来,今日方知我是我
✨当前学习内容: 《C++学习》
📑 目录
一、前置讲解
在进入正文前,先花 10 秒了解本篇会反复用到的核心概念,带着印象去读正文,学习效率更高。
🚨 前置知识一:异常导致泄漏
异常会打破程序线性执行 ,new 出来的内存可能走不到 delete,于是泄漏。
🏗️ 前置知识二:RAII
构造时获取资源、析构时释放资源,把资源托管给对象,让它跟着对象生命周期走。
🔑 前置知识三:指针行为
智能指针要重载 operator* 和 operator->,用起来才像真指针。
🚫 前置知识四:三种所有权策略
auto_ptr 管理权转移 、unique_ptr 禁止拷贝 、shared_ptr 引用计数共享。
🔁 前置知识五:循环引用与 weak_ptr
两个 shared_ptr 互相指,计数永远减不到 0------用不增加计数的 weak_ptr 打破环。
二、为什么需要智能指针
先分析下面这段程序有没有内存方面的问题:
cpp
#include <iostream>
#include <stdexcept>
using namespace std;
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
// 1、如果 p1 这里 new 抛异常会如何?无问题(注意p1还没执行)
// 2、如果 p2 这里 new 抛异常会如何?p1 内存泄漏(注意p2还没执行)
// 3、如果 div 调用这里又会抛异常会如何?p1、p2 都内存泄漏
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;
}
}
运行结果:
输入:4 0
输出:除0错误
new/调用点抛出异常 |
后果 |
|---|---|
p1 处 new 抛异常 |
无问题(此时还没有别的资源) |
p2 处 new 抛异常 |
p1 内存泄漏 (还没走到 delete p1) |
div() 抛异常 |
p1、p2 都泄漏 |
之所以会发生这样的问题,是因为异常会打破原来程序线性执行的特性,导致有些代码没有执行(因此可能产生内存泄漏)。
💡 注意:这段代码逻辑上完全正确 ,
delete一个都没少------但throw一出现,后面的代码直接不执行了 ,delete自然被跳过。这就是"异常安全"要解决的问题。
三、智能指针的使用及原理
3.1 RAII
RAII 是一种利用对象生命周期来控制程序资源(如内存、文件句柄、网络连接、互斥量等等)的简单技术。
在对象构造时获取资源 ,接着控制对资源的访问,使之在对象的生命周期内始终保持有效 ,最后在对象析构的时候释放资源 。借此,我们实际上把管理一份资源的责任托管给了一个对象。
这种做法有两大好处:
| 好处 | 说明 |
|---|---|
| 不需要显式释放资源 | 对象析构时自动 释放,不用写 delete |
| 资源在生命周期内始终有效 | 只要对象活着,资源就一定还在 |
cpp
// 使用 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()
{
SmartPtr<int> sp1(new int);
SmartPtr<int> sp2(new int);
cout << div() << endl;
}
int main()
{
try
{
Func();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
}
运行结果:
输入:4 0
输出:除0错误
💡 输出和上面一模一样,但这一次没有泄漏 :
div()抛异常后,栈展开会析构sp1、sp2,它们的析构函数里自动delete------资源跟着对象走,异常也带不走。
3.2 智能指针的原理
上述的 SmartPtr 还不能称为智能指针 ,因为它还不具有指针的行为 。指针可以解引用 ,也可以通过 -> 去访问所指空间中的内容。因此 SmartPtr 模板类中还得把 *、-> 重载一下,才能让它像指针一样去使用:
cpp
// 在原来类的基础上补上这两段代码
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
总结一下智能指针的原理:
| 原理 | 说明 |
|---|---|
| ① RAII 特性 | 构造拿资源、析构放资源,自动管理生命周期 |
② 重载 operator* 和 operator-> |
具有像指针一样的行为 ,可以 *sp、sp->member |
四、智能指针的种类
4.1 auto_ptr:管理权转移
auto_ptr 的实现原理:管理权转移的思想。
cpp
template<class T>
class auto_ptr
{
public:
auto_ptr(T* ptr)
: _ptr(ptr)
{}
auto_ptr(auto_ptr<T>& sp)
: _ptr(sp._ptr)
{
// 管理权转移
sp._ptr = nullptr;
}
auto_ptr<T>& operator=(auto_ptr<T>& ap)
{
// 检测是否为自己给自己赋值
if (this != &ap)
{
// 把当前指针进行析构
delete _ptr;
// 转移 ap 中资源到当前对象中,然后给 ap 置空
_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;
};
总结一下 auto_ptr :它面对拷贝和赋值 采用的是置空法 ------我用 B 去构造或赋值 A,两个对象势必会指向同一空间,auto_ptr 的处理办法是把 B 的指针直接置空(管理权转移)。
| 优点 | 缺点 |
|---|---|
| 思路简单,能防重复释放 | 被转移的一方变成空指针 ,后续再用就是空指针访问 ------这是很严重的问题,所以它很早就被淘汰了 |
💡 更隐蔽的坑:拷贝构造会"偷走"资源------把
auto_ptr按值传给函数 时,形参的拷贝会把实参的指针偷走并置空,外面那个已经变成空指针。
cpp
void UseAutoPtr(auto_ptr<int> ap)
{
cout << "函数内:" << *ap << endl;
}
int main()
{
auto_ptr<int> p(new int(10));
UseAutoPtr(p);
cout << *p << endl;
}
运行结果:
函数内:10
(程序崩溃)
💡 为什么崩?
UseAutoPtr(p)是值传递 :拷贝构造把p._ptr拿走、同时把p._ptr置空 ;回到main时p已经是空指针 ,*p就是解引用空指针。
4.2 unique_ptr:简单粗暴的防拷贝
unique_ptr 的实现原理:简单粗暴的防拷贝。
cpp
template<class T>
class unique_ptr
{
public:
unique_ptr(T* ptr)
: _ptr(ptr)
{}
~unique_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;
// 移动构造
unique_ptr(unique_ptr&& sp)
: _ptr(sp._ptr)
{
sp._ptr = nullptr;
}
// 移动赋值
unique_ptr& operator=(unique_ptr&& sp)
{
if (this != &sp)
{
delete _ptr;
_ptr = sp._ptr;
sp._ptr = nullptr;
}
return *this;
}
private:
T* _ptr;
};
总结一下 unique_ptr :它面对拷贝和赋值 采用的是禁止法 ------不允许 用 B 去构造或赋值 A(= delete);如果确实要转移所有权,只允许右值引用 (也就是配合上一节的移动语义)。
| 对比项 | auto_ptr |
unique_ptr |
|---|---|---|
| 拷贝 | 允许,但把源对象置空 | 直接禁止 (= delete) |
| 转移所有权 | 隐式发生,防不胜防 | 必须是右值 (std::move),显式 |
| 安全性 | 差(源对象被偷偷置空) | 好(编译期就拦住误用) |
| 现状 | 已废弃 | 推荐默认使用 |
4.3 shared_ptr:引用计数共享
shared_ptr 的原理:通过引用计数的方式来实现多个 shared_ptr 对象之间共享资源。
| 规则 | 说明 |
|---|---|
| 1 | shared_ptr 在其内部,给每个资源都维护了一份计数 ,用来记录该份资源被几个对象共享 |
| 2 | 在对象被销毁时(也就是析构函数调用) ,就说明自己不使用该资源了,对象的引用计数减一 |
| 3 | 如果引用计数是 0 ,就说明自己是最后一个使用该资源的对象,必须释放该资源 |
| 4 | 如果不是 0 ,就说明除了自己还有其他对象在使用该份资源,不能释放该资源 ,否则其他对象就成野指针了 |
cpp
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
: _ptr(ptr)
, _pcount(new int(1))
{}
~shared_ptr()
{
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
}
}
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
shared_ptr(const shared_ptr<T>& sp)
: _ptr(sp._ptr)
, _pcount(sp._pcount)
{
++(*_pcount);
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
// 这里为什么不用 this == &sp?
// 因为它只能处理 A = A,不能处理 A = B(B 和 A 可能指向同一块资源)
if (_ptr == sp._ptr)
{
return *this;
}
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
}
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
return *this;
}
private:
T* _ptr;
int* _pcount; // 引用计数
};
关于这个代码需要了解的三点:
| 问题 | 答案 |
|---|---|
| 为什么引用计数要用指针? | 如果用普通 int 成员 ,每个 shared_ptr 对象都会自己存一份计数,同一个资源却被算出不同的引用计数,根本没法共享 |
为什么每一个 shared_ptr 只能用一个裸指针初始化一次? |
否则会出现两个 _ptr 指向同一块资源、但 _pcount 各自指向不同的计数,计数就对不上了(正确做法是用拷贝构造/赋值共享同一份计数) |
赋值时为什么用 _ptr == sp._ptr 而不是 this == &sp? |
this == &sp 只能处理 A = A ;而 A = B 时 B 和 A 可能指向同一块资源 ,这时若先 --count 再 ++count,虽然结果碰巧对,但中间可能把资源删掉又用 ,所以统一用比较所指资源来判重 |
总结一下 shared_ptr :它是我们使用最多的智能指针 ,因为它在拷贝和赋值 上交出了 99 分 的答卷------可是为什么不是 100 呢?看下面。
4.4 循环引用与 weak_ptr

循环引用是 shared_ptr 的弊端 ,解决方式是内部使用 weak_ptr ------weak_ptr 没有 RAII (不管理资源、不负责释放),它是配合 shared_ptr 使用的。
cpp
template<class T>
class weak_ptr
{
public:
weak_ptr()
: _ptr(nullptr)
, _pcount(nullptr)
{}
// 从 shared_ptr 构造:只"观察",不增加引用计数
weak_ptr(const shared_ptr<T>& sp)
: _ptr(sp._ptr)
, _pcount(sp._pcount)
{}
// 检查被管理的对象是否已被销毁
bool expired() const
{
return _pcount == nullptr || *_pcount == 0;
}
private:
T* _ptr; // 观察的对象指针
int* _pcount; // 共享的引用计数(来自 shared_ptr)
// 注意:weak_ptr 要读 shared_ptr 的私有成员,
// 需要在 shared_ptr 里声明:friend class weak_ptr<T>;
};
weak_ptr 解决循环引用的办法 :把其中一个方向(比如 prev)改成 weak_ptr,这样它只观察、不增加引用计数 ,计数就能正常减到 0,不会出现"node1 要析构还要经过 node2 同意" 的死锁局面。
还有一个问题 :如果 weak_ptr 不支持 * 和 -> ,那怎么通过它查询对象内容?------办法是给 weak_ptr 一个转换成 shared_ptr 的方法 ,标准里就是 lock():
weak_ptr 接口 |
作用 |
|---|---|
expired() |
判断被观察的对象是否已经销毁 |
lock() |
尝试提升为 shared_ptr :对象还在就返回有效 shared_ptr(计数 +1),已销毁就返回空 |
use_count() |
查看当前的引用计数 |
三种智能指针对比:
| 智能指针 | 所有权策略 | 能否拷贝 | 引用计数 | 适用场景 |
|---|---|---|---|---|
auto_ptr |
管理权转移(置空源) | 能(危险) | 无 | 已废弃,别用 |
unique_ptr |
独占 | 不能(只能移动) | 无 | 默认首选,独占资源 |
shared_ptr |
共享 | 能 | 有 | 多处共享所有权 |
weak_ptr |
观察 | 能 | 只读计数、不加 | 打破循环引用 |
五、复盘(附答案)
💡 思考题
-
为什么需要智能指针 :
Func里那段代码逻辑没错、delete也没少写,为什么会内存泄漏? -
RAII:它是什么?为什么能解决上面的泄漏问题?有哪两大好处?
-
智能指针的构成:光有 RAII 够吗?还差什么才能"像指针一样"用?
-
auto_ptr:它的原理是什么?为什么会被淘汰? -
unique_ptr:它怎么防拷贝?既然禁止了拷贝,那"转移所有权"靠什么实现? -
shared_ptr:引用计数为什么要用指针 存?为什么一个裸指针只能初始化一次 ?赋值时比较_ptr == sp._ptr而不用this == &sp是为什么? -
循环引用 :它是怎么产生的?
weak_ptr为什么不加重计数也能用?想通过weak_ptr访问对象该调什么?
📝 答案
-
因为
throw会打破程序的线性执行 :一旦div()抛异常,delete p1、delete p2根本执行不到 ,栈一展开函数就退出了,于是new出来的内存泄漏 。代码"看着没错",但异常路径上少执行了释放。 -
RAII 是利用对象生命周期控制资源 :构造时获取资源、析构时释放资源 ,把管理责任托管给对象 。因为栈展开一定会析构局部对象 ,所以即使抛异常,资源也会被释放------这就是它能解决泄漏的原因。两大好处:不需要显式释放资源 、资源在对象生命周期内始终保持有效。
-
不够。光有 RAII 只能自动释放资源,但用起来不像指针 。还要重载
operator*和operator->,让它能*sp、sp->member,才真正"像指针一样使用"。 -
原理是管理权转移 :拷贝/赋值时把源对象的指针交给新对象、并把源对象置空 ,从而避免同一块资源被释放两次。被淘汰的原因是源对象会被偷偷置空,后续再访问就是空指针。
-
用
= delete删掉拷贝构造和拷贝赋值 ,编译期就拦住拷贝。转移所有权靠移动构造 / 移动赋值 :把对方的指针拿过来、给对方置空------必须用右值 (std::move)才能触发,显式表达"我确实要转移"。 -
计数用指针 是为了让所有
shared_ptr共享同一份计数 ;若用普通 int 成员,每个对象各存一份,同一个资源会算出不同计数。裸指针只能初始化一次 ,否则两个shared_ptr各 new 一个计数来管同一块资源,计数对不上、会重复释放。赋值时用_ptr == sp._ptr,是因为this == &sp只能处理自己给自己赋值 ,处理不了两个不同对象指向同一块资源的情况。 -
循环引用是两个
shared_ptr互相指向对方 :各自计数都是 1,谁都不肯先释放,于是永远减不到 0 ,资源泄漏。weak_ptr只观察、不增加计数 ,把环中一个方向改成weak_ptr后计数就能正常归零。想访问对象内容用lock()提升成shared_ptr(对象已销毁则返回空),配合expired()判断有效性。
结语
如果本文对你有帮助,欢迎:
👍 点赞 | ⭐ 收藏 | 👤 关注作者 | 💬 留言交流你的疑问或补充
你的每一次互动都是我继续更新的动力,我们下一篇见!🚀