C++进阶异常处理与智能指针实战指南

目录

• C++ 进阶：异常处理与智能指针实战指南
• 一、C++ 异常：告别错误码的优雅解决方案
• 1.1 先看 C 语言错误处理的痛点
• 1.2 异常的基本用法：try/throw/catch
• 1.3 异常的核心规则：必须掌握的细节
• 1.4 异常安全：那些不能踩的坑
• 1.5 实战：自定义异常体系（企业级规范）
• 1.6 标准库异常体系：了解即可
• 1.7 异常的优缺点总结
• 二、智能指针：解决异常资源泄漏的 “神器”
• 2.1 先看异常引发的隐患：内存泄漏
• 2.2 RAII 思想：智能指针的基石
• 三、C++ 智能指针全家桶：原理与实战
• 3.1 auto_ptr：失败的早期尝试（避坑）
• 3.2 unique_ptr：独占所有权的高效选择
• 3.3 shared_ptr：共享所有权的灵活方案
• 3.4 weak_ptr：破解 shared_ptr 循环引用
• 四、C++11 与 boost 智能指针的渊源
• 五、总结：异常与智能指针的最佳实践

C++ 进阶：异常处理与智能指针实战指南

在 C++ 开发中，“错误处理” 与 “资源管理” 是两大核心痛点。传统 C 语言的错误处理方式繁琐且脆弱，而手动管理内存又容易因异常导致泄漏。本文将从异常机制入手，逐步过渡到智能指针，带你掌握 C++ 中可靠编程的关键技术，解决 “如何优雅处理错误” 与 “如何安全管理资源” 两大难题。

一、C++ 异常：告别错误码的优雅解决方案

在 C 语言中，我们习惯用assert终止程序或返回错误码处理问题，但这些方式存在明显局限。C++ 异常机制的出现，让错误处理更灵活、信息更完整。

1.1 先看 C 语言错误处理的痛点

C 语言处理错误的两种核心方式，都有难以规避的缺陷：

• 终止程序（如 assert）：过于粗暴，用户无法接受（比如内存错误直接崩溃）；
• 返回错误码：需要手动检查每个函数返回值，深层调用链中需 “层层传递” 错误，代码冗余且易遗漏。

举个例子，若ConnectSql函数返回错误码，调用链需逐层传递才能让外层处理：

// C语言风格：错误码层层传递的冗余
int ConnectSql() {
    if (权限不足) return 1;
    if (连接失败) return 2;
    return 0;
}
int ServerStart() {
    int ret = ConnectSql();
    if (ret != 0) return ret; // 手动传递错误码
    int fd = socket();
    if (fd < 0) return errno; // 再传递系统错误码
}
int main() {
    int ret = ServerStart();
    if (ret != 0) {
        // 还需根据错误码查表判断具体问题
        printf("错误码：%d\n", ret);
    }
    return 0;
}

1.2 异常的基本用javascript法：try/throw/catch

C++ 通过try（保护代码）、throw（抛出异常）、catch（捕获异常）三段式处理错误，核心逻辑是 “哪里出错抛哪里，哪里能处理哪里接”。

语法框架

try {
    // 可能抛出异常的“保护代码”
    函数调用或危险操作;
} catch (异常类型1 e1) {
    // 处理类型1的异常
} catch (异常类型2 e2) {
    // 处理类型2的异常
} catch (...) {
    // 捕获所有未匹配的异常（兜底，避免程序崩溃）
}

实战示例：除 0 错误处理

用异常重构 “除 0 错误”，无需层层传递错误码：

#include <IOStream>
using namespace std;
// 发生除0时抛出异常
double Division(int a, int b) {
    if (b == 0) {
        // 抛出字符串异常（也可抛自定义对象）
        throw "Division by zero condition!";
    }
    return (double)a / b;
}
void Func() {
    int len, time;
    cin >> len >> time;
    // 若Division抛异常，直接跳转到catch
    cout << Division(len, time) << endl;
}
int main() {
    try {
        Func();
    } catch (const char* errmsg) {
        // 捕获字符串类型异常，打印错误信息
        cout << "错误：" << errmsg << endl;
    } catch (...) {
        // 兜底：捕获所有其他类型异常
        cout << "未知异常" << endl;
    }
    return 0;
}

1.3 异常的核心规则：必须掌握的细节

异常的抛出与捕获并非 “随便匹配”，需遵守以下规则，否则易导致程序崩溃：

（1）匹配原则：类型决定捕获逻辑

• 异常对象的类型决定了哪个catch会被激活；
• 允许 “派生类对象抛，基类捕获”（实战中常用此特性设计异常体系）；
• catch(...)是 “万能捕获”，但无法获取异常具体信息，需谨慎使用。

（2）栈展开：从抛出点找捕获点

若throw不在try内，或try后无匹配的catch，会触发 “栈展开”：

• 退出当前函数栈，回到调用者的栈帧；
• 重复检查调用者的try/catch，直到找到匹配的catch；
• 若一直找到main函数仍无匹配，程序直接终止。

（3）异常重新抛出：部分处理后移交外层

若单个catch无法完全处理异常（比如仅释放资源），可通过throw;重新抛出，让外层处理：

void Func() {
    // 申请资源（若抛异常需释放）
    int* array = new int[10];
    try {
        int len, time;
        cin >> len >> time;
        cout << Division(len, time) << endl;
    } catch (...) {
        // 先释放资源，再重新抛出异常
        cout << "释放array：" << array << endl;
        delete[] array;
        throw; // 移交外层处理
    }
    // 正常执行时释放资源
    delete[] array;
}

1.4 异常安全：那些不能踩的坑

异常虽好，但若使用不当，会导致资源泄漏、对象不完整等问题，核心注意两点：

（1）构造函数：尽量不抛异常

构造函数负责对象初始化，若中途抛异常，对象可能处于 “半初始化” 状态（部分成员已创建，部分未创建），导致资源泄漏。

（2）析构函数：绝对不抛异常

析构函数负责资源清理（如delete、关闭文件），若抛异常：

• 若已有一个异常在处理中，会直接终止程序；
• 可能导致资源未释放（如delete未执行）。

1.5 实战：自定义异常体系（企业级规范）

实际项目中，若随意抛int、string等零散类型，外层无法统一处理。规范做法是设计继承式异常体系：定义一个基类，所有具体异常继承自它，外层只需捕获基类即可。

企业级异常体系示例

#include <string>
using namespace std;
// 异常基类
class Exception {
public:
    Exception(const string& errmsg, int id) 
        : _errmsg(errmsg), _id(id) {}
    // 虚函数：支持多态，子类重写错误信息
    virtual string what() const {
        return _errmsg;
    }
protected:
    string _errmsg; // 错误描述
    int _id;        // 错误编号（便于定位问题）
};
// SQL异常（派生类）
class SqlException : public Exception {
public:
    SqlException(const string& errmsg, int id, const string& sql)
        : Exception(errmsg, id), _sql(sql) {}
    // 重写what，添加SQL信息
    virtual string what() const override {
        string str = "SqlException: ";
        str += _errmsg;
        str += " (SQL: ";
        str += _sql;
        str += ")";
        return str;
    }
private:
    string _sql; // 出问题的SQL语句
};
// 缓存异常（派生类）
class CacheException : public Exception {
public:
    CacheException(const string& errmsg, int id)
        : Exception(errmsg, id) {}
    virtual string what() const override {
        return "CacheException: " + _errmsg;
    }
};
// 模拟SQL操作：随机抛异常
void SQLMgr() {
    srand(time(0));
    if (rand() % 7 == 0) {
        throw SqlException("权限不足", 100, "select * from user where name='张三'");
    }
}
// 模拟缓存操作：随机抛异常
void CacheMgr() {
    srand(time(0));
    if (rand() % 5 == 0) {
        throw CacheException("数据不存在", 101);
    }
    SQLMgr(); // 调用SQL操作
}
int main() {
    while (1) {
        this_thread::sleep_for(chrono::seconds(1));
        try {
            CacheMgr();
            cout << "操作成功" << endl;
        } catch (const Exception& e) {
            // 捕获基类，统一处理所有异常（多态生效）
            cout << "捕获异常：" << e.what() << endl;
        } catch (...) {
            cout << "未知异常" << endl;
        }
    }
    return 0;
}

优势

• 外层只需一个catch(const Exception& e)，即可处理所有派生类异常；
• 错误信息结构化（含错误编号、SQL 语句等），便于定位问题；
• 扩展性强：新增异常类型只需继承基类，无需修改外层捕获逻辑。

1.6 标准库异常体系：了解即可

C++ 标准库定义了一套异常体系（头文件<exception>），所有异常继承自std::exception，但实际中很少直接使用 —— 因为设计较简单，无法满足复杂业务需求（如无法携带错误编号、SQL 语句等）。

核心继承关系：

std::exception
├─ std::bad_alloc（new失败时抛）
├─ std::bad_cast（dynamic_cast失败时抛）
├─ std::logic_error（逻辑错误，如参数无效）
│  ├─ std::invalid_argument（无效参数）
│  └─ std::out_of_range（越界，如vector::at）
└─ std::runtime_error（运行时错误）
   └─ std::overflow_error（算术溢出）

使用示例（捕获vector越界异常）：

#include <vector>
#include <exception>
int main() {
    try {
        vector<int> v(10);
        v.at(10) = 100; // 越界，抛out_of_range
    } catch (const exception& e) {
        // 调用what()获取错误信息
        cout << e.what() << endl; // 输出：vector::_M_range_check: __n (which is 10) >= this->size() (which is 10)
    }
    return 0;
}

1.7 异常的优缺点总结

结论：异常利大于弊，是 C++ 错误处理的主流方案，关键是配合智能指针解决资源泄漏问题。

二、智能指针：解决异常资源泄漏的 “神器”

异常会导致代码执行流跳变，若new后抛异常，delete可能无法执行，进而引发内存泄漏。智能指针的出现，正是通过RAII 思想，让资源自动释放。

2.1 先看异常引发的隐患：内存泄漏

以下代码中，若Func()抛异常，delete p会被跳过，导致内存泄漏：

void Func() {
    throw "模拟异常"; // 抛出异常
}
void Test() {
    int* p = new int; // 申请内存
    Func();           // 抛异常，执行流跳走
    delete p;         // 永远不会执行，内存泄漏
}

内存泄漏定义：程序分配内存后，因设计错误失去对该内存的控制，导致内存无法复用，长期运行会使程序响应变慢甚至卡死。

2.2 RAII 思想：智能指针的基石

RAII（Resource Acquisition Is Initialization），即 “资源获取即初始化”，核心逻辑是：

• 构造时获取资源：将资源（如内存、文件句柄）绑定到对象的生命周期；
• 析构时释放资源：对象销毁时，析javascript构函数自动释放资源，无需手动调用。

基于 RAII 的简单智能指针

template<class T>
class SmartPtr {
public:
    // 构造：获取资源（内存）
    SmartPtr(T* ptr = nullptr) : _ptr(ptr) {}
    // 析构：释放资源（内存）
    ~SmartPtr() {
        if (_ptr) {
            delete _ptr;
            cout << "释放内存：" << _ptr << endl;
        }
    }
    // 重载*和->，让SmartPtr像普通指针一样使用
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
private:
    T* _ptr; // 管理的资源（内存地址）
};
// 测试：即使抛异常，内存也会自动释放
void Test() {
    SmartPtr<int> sp(new int); // 构造：获取内存
    *sp = 10;                  // 像普通指针一样使用
    throw "模拟异常";           // 抛异常，sp对象销毁时调用析构
    // 无需手动delete，析构自动释放
}

核心优势

• 无需显式释放资源，避免人为遗漏；
• 即使发生异常，对象也会被销毁（栈对象在栈展开时自动析构），资源必然释放。

三、C++ 智能指针全家桶：原理与实战

C++ 标准库提供了 4 种智能指针，分别应对不同场景，其中auto_ptr已被淘汰，重点掌握unique_ptr、shared_ptr和weak_ptr。

3.1 auto_ptr：失败的早期尝试（避坑）

auto_ptr是 C++98 提供的第一个智能指针，采用 “管理权转移” 机制，但存在严重缺陷，企业中已明确禁止使用。

缺陷：管理权转移导致悬空指针

当auto_ptr对象拷贝或赋值时，会转移资源的管理权，原对象变为 “悬空指针”（指向 nullptr），访问原对象会崩溃：

#include <memory> // auto_ptr所在头文件
int main() {
    auto_ptr<int> sp1(new int(10));
    auto_ptr<int> sp2 = sp1; // 管理权转移：sp1失去资源，sp2拥有资源
    *sp2 = 20; // 正常：sp2拥有资源
    *sp1 = 30; // 崩溃：sp1已悬空（指向nullptr）
    return 0;
}

结论：永远不要使用auto_ptr，改用unique_ptr。

3.2 unique_ptr：独占所有权的高效选择

unique_ptr是 C++11 替代auto_ptr的方案，核心是独占资源所有权—— 同一时间，只有一个unique_ptr能管理资源，禁止拷贝和赋值（直接删除拷贝构造和赋值运算符）。

核心特性

• 禁止拷贝：unique_ptr(const unique_ptr&) = delete;
• 禁止赋值：unique_ptr& operator=(const unique_ptr&) = delete;
• 支持移动语义：可通过std::move转移所有权（转移后原对象悬空）。

实战示例

#include <memory>
int main() {
    // 1. 基本使用
    unique_ptr<int> sp1(new int(10));
    cout << *sp1 << endl; // 10
    // 2. 禁止拷贝和赋值（编译报错）
    // unique_ptr<int> sp2 = sp1; // 错误：拷贝构造已删除
    // sp1 = sp2;                // 错误：赋值运算符已删除
    // 3. 移动语义：转移所有权
    unique_ptr<int> sp2 = std::move(sp1); // 转移后sp1悬空
    cout << *sp2 << endl; // 10
    // cout << *sp1 << endl; // 崩溃：sp1已悬空
    // 4. 管理数组（需指定删除器，或用unique_ptr<int[]>）
    unique_ptr<int[]> sp3(new int[5]); // 专门用于数组，析构时调用delete[]
    sp3[0] = 1;
    sp3[1] = 2;
    return 0;
}

适用场景

• 资源仅需一个所有者（如局部变量、函数返回值）；
• 追求高效（无引用计数开销，性能接近普通指针）。

3.3 shared_ptr：共享所有权的灵活方案

unique_ptr不支持拷贝，无法满足 “多对象共享资源” 的场景（如多线程共享数据）。shared_ptr通过引用计数实现共享所有权，核心是 “记录资源被多少对象引用，最后一个对象销毁时释放资源”。

核心原理

• 每个shared_ptr管理一个资源和一个 “引用计数”（记录共享该资源的shared_ptr数量）；
• 拷贝shared_ptr时，引用计数 + 1；
• shared_ptr销毁时，引用计数 - 1；
• 若引用计数变为 0，释放资源。

模拟实现核心代码

template<class T>
class shared_ptr {
public:
    // 构造：资源+引用计数（初始为1）
    shared_ptr(T* ptr = nullptr) 
        : _ptr(ptr), _pRefCount(new int(1)), _pmtx(new mutex) {}
    // 拷贝构造：引用计数+1
    shared_ptr(const shared_ptr<T>& sp) 
        : _ptr(sp._ptr), _pRefCount(sp._pRefCoun编程客栈t), _pmtx(sp._pmtx) {
        AddRef(); // 引用计数+1（加锁保证线程安全）
    }
    // 赋值运算符：释放当前资源，引用新资源
    shared_ptr<T>& operator=(const shared_ptr<T>& sp) {
        if (_ptr != sp._ptr) { // 避免自赋值
            Release(); // 释放当前资源（引用计数-1，为0则删除）
            _ptr = sp._ptr;
            _pRefCount = sp._pRefCount;
            _pmtx = sp._pmtx;
            AddRef(); // 新资源引用计数+1
        }
        return *this;
    }
    // 析构：引用计数-1，为0则释放资源
    ~shared_ptr() {
        Release();
    }
    // 重载*和->
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    // 获取引用计数
    int use_count() const { return *_pRefCount; }
private:
    // 引用计数+1（加锁，线程安全）
    void AddRef() {
        _pmtx->lock();
        (*_pRefCount)++;
        _pmtx->unlock();
    }
    // 引用计数-1，为0则释放资源
    void Release() {
        _pmtx->lock();
        bool needDelete = false;
        if (--(*_pRefCount) == 0) {
            delete _ptr;
            delete _pRefCount;
            needDelete = true;
        }
        _pmtx->unlock();
        if (needDelete) {
            delete _pmtx; // 最后一个对象销毁时，删除锁
        }
    }
private:
    T* _ptr;          // 管理的资源
    int* _pRefCount;  // 引用计数（指针：所有共享对象共享同一计数）
    mutex* _pmtx;     // 互斥锁：保证引用计数操作线程安全
};

实战要点

• 线程安全：
  • 引用计数的加减是线程安全的（内部加锁）；
  • 资源本身的访问不是线程安全的（需用户手动加锁）。
• 自定义删除器：
  • shared_ptr默认用delete释放资源，若资源是malloc分配的、数组或文件句柄，需自定义删除器：

#include <cstdlib> // malloc/free
#include <cstdio>  // FILE/fclose
// 1. 管理malloc分配的内存（自定义删除器）
void FreeFunc(int* ptr) {
    free(ptr);
    cout << "free内存：" << ptr << endl;
}
shared_ptr<int> sp1((int*)malloc(4), FreeFunc);
// 2. 管理数组（用lambda作为删除器）
shared_ptr<int> sp2(new int[5], [](int* ptr) {
    delete[] ptr;
    cout << "delete[]数组：" << ptr << endl;
});
// 3. 管理文件句柄
shared_ptr<FILE> sp3(fopen("test.txt", "w"), [](FILE* ptr) {
    fclose(ptr);
    cout << "关闭文件：" << ptr << endl;
});

3.4 weak_ptr：破解 shared_ptr 循环引用

shared_ptr存在一个致命问题：循环引用—— 两个shared_ptr互相引用，导致引用计数无法归零，资源永远无法释放。

问题示例：双向链表节点

struct ListNode {
    int _data;
    shared_ptr<ListNode> _prev; // 指向前驱节点
    shared_ptr<ListNode> _next; // 指向后继节点
    ~ListNode() { cout << "~ListNode()" << endl; }
};
int main() {
    shared_ptr<ListNode> node1(new ListNode);
    shared_ptr<ListNode> node2(new ListNode);
    cout << node1.use_count() << endl; // 1
    cout << node2.use_count() << endl; // 1
    node1->_next = node2; // node1的_next引用node2，node2计数变为2
    node2->_prev = node1; // node2的_prev引用node1，node1计数变为2
    // 析构node1和node2：计数各减1，变为1（非0），资源不释放
    return 0;
}

循环引用分析

• node1和node2析构时，引用计数从 2 减到 1（因_next和_prev仍互相引用）；
• 只有_next和_prev析构时，计数才会减到 0，但_next属于node1，node1不释放则_next不析构；
• 最终形成 “死锁”，资源永远无法释放。

解决方案：用 weak_ptr 打破循环

weak_ptr是 “弱引用” 智能指针，特点是：

• 不增加引用计数，仅观察资源；
• 无法直接访问资源（需先通过lock()转为shared_ptr）。

修改链表节点，将_prev和_next改为weak_ptr：

#include <memory>
struct ListNode {
    int _data;
    weak_ptr<ListNode> _prev;  // 弱引用：不增加计数
    weak_ptr<ListNode> _next;  // 弱引用：不增加计数
    ~ListNode() { cout << "~ListNode()" << endl; }
};
int main() {
    shared_ptr<ListNode> node1(new LisphptNode);
    shared_ptr<ListNode> node2(new ListNode);
    cout << node1.use_count() << endl; // 1
    cout << node2.use_count() << endl; // 1
    node1->_next = node2; // weak_ptr赋值，node2计数仍为1
    node2->_prev = node1; // weak_ptr赋值，node1计数仍为1
    // 析构node1和node2：计数减到0，资源释放（打印~ListNode()）
    return 0;
}

weak_ptr 的使用场景

• 打破shared_ptr的循环引用（如双向链表、树结构）；
• 观察资源是否存在（通过lock()判断：若资源存在，返回非空shared_ptr；否则返回空）。

四、C++11 与 boost 智能指针的渊源

C++11 的智能指针并非凭空出现，而是借鉴了boost库的设计：

• C++98：仅提供auto_ptr，设计缺陷明显；
• boost 库：提出scoped_ptr（独占）、shared_ptr（共享）、weak_ptr（弱引用），解决了auto_ptr的问题；
• C++ TR1：引入shared_ptr，但非标准；
• C++11：正式纳入unique_ptr（对应boost::scoped_ptr）、shared_ptr、weak_ptr，并优化实现。

结论：C++11 智能指针是boost智能指http://www.devze.com针的 “标准化版本”，兼容性更好，无需额外依赖boost库。

五、总结：异常与智能指针的最佳实践

1. 异常使用规范：

• 定义继承式异常体系，所有异常继承自同一基类；
• 构造函数尽量不抛异常，析构函数绝对不抛异常；
• 外层用catch(...)兜底，避免程序崩溃。

1. 智能指针选择优先级：

• 优先用unique_ptr（独占资源，高效无开销）；
• 需共享资源时用shared_ptr（注意循环引用，用weak_ptr解决）；
• 永远不用auto_ptr。

1. 资源管理原则：

• 内存、文件句柄等资源，优先用智能指针管理；
• 自定义资源（如网络连接），用 RAII 思想封装成类，让资源自动释放。

通过 “异常处理错误”+“智能指针管理资源”，可大幅提升 C++ 程序的可靠性和可维护性，这也是企业级 C++ 开发的核心技术之一。

到此这篇关于C++异常处理与智能指针实战指南的文章就介绍到这了,更多相关C++异常与智能指针内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！