C++ 异常处理机制详解：从原理到实战

为什么 C++ 需要异常处理？

在 C 语言中，错误处理通常依赖整型返回值或全局变量 errno。这两种方法存在明显缺陷：返回值语义不统一（0 或 1 表示成功）、只能返回单一数据而占用业务逻辑返回值。相比之下，C++ 引入了独立的异常处理机制，允许错误信息像数据一样在调用栈中向上传递，实现了错误处理与业务逻辑的解耦。

第 1 步：异常的抛出与捕获

目的：在检测到错误的函数中中断当前流程，并在调用链上游寻找合适的处理器。
入口：使用 throw 语句抛出对象或类型标识，使用 try...catch 块捕获。
动作：
1. 在可能出错的操作外围包裹 try 块。
2. 在检测到条件（如除数为 0）时使用 throw 值; 抛出异常。
3. 编写 catch (类型名) 来接收并处理对应类型的异常。

例如，处理整数除法时，如果无法处理 b==0，可以向上抛出 -1 或具体的错误码。如果需要“万能”捕获，可以使用 catch (...)。

int myDivision(int a, int b)
{
    if (b == 0)
    {
        throw -1; // 抛出异常
    }
    else
        return a / b;
}

int main()
{
    int a = 10;
    int b = 0;
    try 
    {
        myDivision(a, b);
    }
    catch (int) // 捕获 int 类型异常
    {
        cout << "int类型异常捕获" << endl;
    }
    return 0;
}

如果当前层级捕获了异常但选择继续向上一层抛出，只需在 catch 块中使用 throw;（无参数）即可重抛当前异常。

第 2 步：利用自定义类封装异常

目的：提供更丰富、结构化的错误上下文信息。
关键参数：类对象的实例化。
说明：抛出具体类型的数据需要对应的接收端。使用类作为异常类型不仅支持更复杂的数据结构，还能配合多态特性。当异常被抛出时，创建类的匿名对象。

class MyException
{
public:
    void printError()
    {
        cout << "我自己的异常" << endl;
    }
};

void func() { throw MyException(); }

核心概念与进阶操作

第 3 步：理解“栈解旋” (Stack Unwinding)

说明：这是 C++ 异常处理最强大的自动特性之一。
规则：从进入 try 块开始，直到 throw 抛出异常之前，所有在该作用域内创建的局部对象（包括栈上的对象），都会按照“先进后出”的顺序依次进行析构释放，这个过程称为栈解旋。这确保了即使在发生严重错误导致函数非正常退出时，内存和系统资源也能被正确回收，避免资源泄露。

class Person
{
public:
    Person() { cout << "Person的默认构造调用" << endl; }
    ~Person() { cout << "Person的析构调用" << endl; }
};

void myDivision(int a, int b)
{
    if (b == 0)
    {
        Person p1; // 构造
        Person p2; // 构造
        throw Person(); // 抛出前，p1 和 p2 会按逆序自动析构！
    }
}

第 4 步：优化异常变量生命周期

目的：减少对象拷贝带来的性能损耗。
风险点：若 catch 采用值接收（catch(MyException e)），会发生一次拷贝构造；若异常类对象在抛出瞬间析构，再次析构可能导致不可预知的行为。

• 指针接收：catch (MyException *e)。如果在 throw 时使用了 throw new MyException()，则避免了栈上的自动析构，但需手动 delete，极易引发内存泄漏，不建议使用。
• 引用接收（推荐）：catch (const MyException &e)。直接绑定到抛出的临时对象，不会触发额外的拷贝构造，且在离开 catch 块前一直有效，是性能最佳且安全的做法。

第 5 步：异常的多态性

利用面向对象的继承特性，可以在基类层面统一处理不同的派生类异常。定义一个包含纯虚函数的基类异常接口，让各种具体异常继承并重写虚函数。这样，调用处只需捕获基类的引用，即可通过多态调用正确的子类方法。

class BaseException
{
public:
    virtual void printError() = 0;
    virtual ~BaseException() {}
};

class NULLPointerException: public BaseException
{
public:
    void printError() override { cout << "空指针异常" << endl; }
};

// 捕获时：
// catch (const BaseException &e) { e.printError(); } // 根据实际抛出的对象动态分派

编写标准化的自定义异常类

在实际工程中，应基于 std::exception 派生自己的异常类，这样既保持了标准库的风格，又利用了其已有的属性。

实现步骤与要求

1. 继承 std::exception：保证可以被通用的 catch(std::exception& e) 捕获。
2. 重写 what() 函数：这是父类提供的虚函数原型为 virtual const char* what() const noexcept;，必须实现以返回描述字符串。
3. 存储错误信息：将传入的错误字符串保存为成员变量。

#include <iostream>
#include <string>
#include <stdexcept>
using namespace std;

// 1. 继承自 exception
class MyOutOfRangeException : public exception
{
private:
    string m_errorMsg;
public:
    // 2. 构造函数接收错误详情
    MyOutOfRangeException(const char* msg)
    {
        this->m_errorMsg = msg;
    }
    
    // 3. 必须重写 what() 且必须是 const 成员函数
    virtual const char* what() const noexcept override
    {
        return m_errorMsg.c_str(); // 转为 C 风格字符串
    }
};

void test(int age)
{
    if (age < 0 || age > 150)
    {
        throw MyOutOfRangeException("年龄超出范围");
    }
}

int main()
{
    try 
    {
        test(200);
    } 
    catch (const MyOutOfRangeException& e)
    {
        cout << e.what() << endl;
    }
    catch (const exception& e)
    {
        cout << "其他标准异常：" << e.what() << endl;
    }
    return 0;
}

以上就是 C++ 中异常处理机制的详细应用教程，更多关于 C++ 底层机制及面向对象设计的资料请关注本站其它相关文章！