【C++ 基础入门】智能指针:RAII、unique_ptr 与 shared_ptr 循环引用

👋 欢迎阅读

🔥愿旖旎 · 个人主页

📘学习专栏: 《算法专栏》《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 观察 能 只读计数、不加 打破循环引用

五、复盘(附答案)

💡 思考题

  1. 为什么需要智能指针 :Func 里那段代码逻辑没错、delete 也没少写,为什么会内存泄漏?

  2. RAII:它是什么?为什么能解决上面的泄漏问题?有哪两大好处?

  3. 智能指针的构成:光有 RAII 够吗?还差什么才能"像指针一样"用?

  4. auto_ptr:它的原理是什么?为什么会被淘汰?

  5. unique_ptr:它怎么防拷贝?既然禁止了拷贝,那"转移所有权"靠什么实现?

  6. shared_ptr :引用计数为什么要用指针 存?为什么一个裸指针只能初始化一次 ?赋值时比较 _ptr == sp._ptr 而不用 this == &sp 是为什么?

  7. 循环引用 :它是怎么产生的?weak_ptr 为什么不加重计数也能用?想通过 weak_ptr 访问对象该调什么?

📝 答案

  1. 因为 throw 会打破程序的线性执行 :一旦 div() 抛异常,delete p1、delete p2 根本执行不到 ,栈一展开函数就退出了,于是 new 出来的内存泄漏 。代码"看着没错",但异常路径上少执行了释放。

  2. RAII 是利用对象生命周期控制资源 :构造时获取资源、析构时释放资源 ,把管理责任托管给对象 。因为栈展开一定会析构局部对象 ,所以即使抛异常,资源也会被释放------这就是它能解决泄漏的原因。两大好处:不需要显式释放资源 、资源在对象生命周期内始终保持有效。

  3. 不够。光有 RAII 只能自动释放资源,但用起来不像指针 。还要重载 operator* 和 operator-> ,让它能 *sp、sp->member,才真正"像指针一样使用"。

  4. 原理是管理权转移 :拷贝/赋值时把源对象的指针交给新对象、并把源对象置空 ,从而避免同一块资源被释放两次。被淘汰的原因是源对象会被偷偷置空,后续再访问就是空指针。

  5. 用 = delete 删掉拷贝构造和拷贝赋值 ,编译期就拦住拷贝。转移所有权靠移动构造 / 移动赋值 :把对方的指针拿过来、给对方置空------必须用右值 (std::move)才能触发,显式表达"我确实要转移"。

  6. 计数用指针 是为了让所有 shared_ptr 共享同一份计数 ;若用普通 int 成员,每个对象各存一份,同一个资源会算出不同计数。裸指针只能初始化一次 ,否则两个 shared_ptr 各 new 一个计数来管同一块资源,计数对不上、会重复释放。赋值时用 _ptr == sp._ptr ,是因为 this == &sp 只能处理自己给自己赋值 ,处理不了两个不同对象指向同一块资源的情况。

  7. 循环引用是两个 shared_ptr 互相指向对方 :各自计数都是 1,谁都不肯先释放,于是永远减不到 0 ,资源泄漏。weak_ptr 只观察、不增加计数 ,把环中一个方向改成 weak_ptr 后计数就能正常归零。想访问对象内容用 lock() 提升成 shared_ptr(对象已销毁则返回空),配合 expired() 判断有效性。


结语

如果本文对你有帮助,欢迎:

👍 点赞 | ⭐ 收藏 | 👤 关注作者 | 💬 留言交流你的疑问或补充

你的每一次互动都是我继续更新的动力,我们下一篇见!🚀

相关推荐
饮水桶_T1 小时前
Python 面向对象(十七)|继承、封装、多态 笔记
数据结构·笔记·算法
ShineWinsu2 小时前
对于Qt:QSpacerItem常见属性以及方法的解析
开发语言·c++·qt·面试·系统架构·客户端·qspaceritem
星恒随风2 小时前
MySQL 从零入门(十):MVCC、Undo Log 与 Read View 详解——InnoDB 如何实现事务隔离?
linux·数据库·笔记·sql·mysql
zdr尽职尽责2 小时前
终端工具凭空消失:Codex + GPT-6 的一次完整排障复盘
数据库·gpt·学习·ai
蒸蒸yyyyzwd4 小时前
计算机网络后端面试错题
笔记·学习
ShineWinsu5 小时前
对于Qt:QGripLayout常见属性、方法以及QSizePolicy的解析
开发语言·c++·qt·面试·gui·客户端·网格
艾莉丝努力练剑5 小时前
【AI大模型接入SDK】C++的SessionManager 线程安全
java·开发语言·前端·c++·人工智能·学习·安全
辰小忆5 小时前
11 · RunCurveChart —— 实时运行曲线
c++·ui·duilib
蒸蒸yyyyzwd6 小时前
数据库相关错题笔记
笔记·学习