C++ 异常处理详解：throw、try-catch 与栈解旋机制

不晚

发布时间：2026-10-15 | 5人浏览过

原创

C++ 中的异常处理机制将错误检测与处理分离，允许函数专注于核心逻辑。通过 throw 抛出异常，try 块包裹可能出错的代码，catch 块负责接收并处理特定类型的异常。

C++ 异常处理基础

在 C 语言中，错误通常通过返回值层层上报，这种方式效率低下且容易导致代码臃肿。C++ 引入了专门的异常处理机制，使底层函数可以独立解决具体问题，而不必过度关注异常流的返回。异常的核心特征包括：

跨越函数调用层级：异常可以在不同层级的函数间传递，不局限于同一函数。
结构化语法：使用 try-catch 结构包裹代码，只有 try 块可以有一个，而 catch 块可以有多个以匹配不同类型。
类型匹配：抛出的异常类型必须与捕获块的参数类型兼容。

第1步：编写 try-catch 结构

目的：定义代码中可能发生异常的区块及对应的处理方式。

操作：将可能抛出异常的代码放入 try 块的花括号内。随后紧跟一个或多个 catch 块。如果不知道具体需要捕获什么类型，可以使用括号 (...) 作为通配符，类似于 switch-case 中的 default。

try 
{
    // 可能产生异常的语句
} 
catch (ExceptionType var) 
{
    // 处理特定异常的逻辑
}

第2步：使用 throw 抛出异常

目的：在检测到错误条件时触发异常处理流程。

操作：在程序任意位置使用 throw 关键字后跟一个值（可以是系统预定义类型或自定义对象）。从抛出到被捕获的过程类似函数赋值。如果是自定义类型，需确保其支持拷贝构造，因为异常传递时会发生拷贝。

异常传递与匹配规则

当 throw 抛出异常时，系统会从当前作用域开始向上回溯查找匹配的 catch 块。如果当前函数内有匹配的处理器，则跳转至该处执行；如果没有匹配，则继续向上一级函数回溯。若最终未在 main 函数前找到任何匹配的 catch，系统将调用终止函数结束进程。

示例：多层函数间的异常传递

以下示例展示了 func1 抛出异常时，如何在嵌套的调用链中传递与拦截：

#include <iostream>
using namespace std;

void func1()
{
    double a = 1.0;
    try{
        throw a; // 抛出 double 类型异常
    }catch(double)
    {
        cout << "catch func1()" << endl; // 在此捕获
    }
    cout << "end func1()" << endl;
}

void func2()
{
    try{
        func1();
    }catch(int)
    {
        cout << "catch func2()" << endl;
    }
    cout << "end func2()" << endl;
}

void func3()
{
    try{
        func2();
    }catch(char)
    {
        cout << "catch func3()" << endl;
    }
    cout << "end func3()" << endl;
}

int main()
{
    try{
        func3();
    }catch(double)
    {
        cout << "catch main" << endl;
    }
    cout << "end main" << endl;
    return 0;
}

运行结果：

catch func1()
end func1()
end func2()
end func3()
end main

在这个例子中，异常首先在 func1 中被 catch(double) 截获，因此不会继续向上传递。随后所有函数的 cout << "end ..." 顺序输出。若将 func1 的捕获类型改为无法匹配的 catch(void *)，异常将继续上溯直到 main 的 catch(double) 将其截获。若所有层级都无法匹配，程序将被强制终止。

异常接口声明

为了增强可读性并约束行为，可以在函数声明中指定可能抛出的异常类型：

void func() throw (A,B,C);     // 限制仅能抛出 A, B, C 及其子类型
void func() throw();           // 承诺不抛出任何异常

如果函数违反了声明约定（如抛出未列出的异常），系统会调用 unexpected 函数并最终导致程序中止。若未做声明，函数可抛出任意类型的异常。

栈解旋（Stack Unwinding）

这是 C++ 异常处理中最关键的安全机制之一。当异常被抛出后，从进入 try 块开始到异常被抛出前的这段期间，在栈上创建的所有局部对象会自动按构造相反的顺序析构。这个过程被称为“栈解旋”。

注意：堆内存（Heap Memory）不会自动释放，如果手动分配了资源（如 new 出来的指针），必须依靠 RAII（资源获取即初始化）模式或智能指针来管理，否则会导致内存泄漏。

示例：栈对象的自动析构

#include <iostream>
using namespace std;

class A {
public:
    A(){ cout << "A()" << endl; }
    ~A(){ cout << "~A()" << endl; }
};

int func1(){
    A a;
    if(1)
        throw('a'); // 抛出字符型异常
    return 0;
}

int func2(){
    A b;
    func1();
    return 1;
}

int main(){
    try{
        func2();
    }catch(...){
        cout << "no x, no y" << endl;
    }
    return 0;
}

输出分析：