C++ `SEH` (Structured Exception Handling)：Windows 平台特有的异常处理机制

哈喽，各位好！今天咱们来聊聊C++在Windows平台下的一个“老朋友”——SEH，也就是Structured Exception Handling，结构化异常处理。这玩意儿虽然名字听起来挺高大上，但其实没那么神秘，掌握了它，能让你在Windows上写出更健壮、更稳定的程序。

一、啥是SEH？为啥要有它？

SEH，简单来说，就是Windows操作系统提供的一种异常处理机制。它跟C++标准的try...catch有点像，但又不太一样。主要区别在于：

适用范围： try...catch主要处理C++的异常对象（通过throw抛出的异常），而SEH则能捕获所有类型的异常，包括硬件异常（比如除零错误、非法内存访问）和软件异常（比如程序自己RaiseException）。
平台依赖性： try...catch是C++标准的一部分，跨平台兼容性好。SEH是Windows特有的，只能在Windows上用。
底层实现： try...catch依赖于C++的异常处理机制，而SEH则直接和Windows内核交互，更底层。

那为啥Windows要搞这么一套SEH呢？原因也很简单：

兼容性： Windows系统本身是用C和汇编写的，很多时候会遇到硬件异常，这些异常try...catch是没法捕获的。SEH可以统一处理这些异常。
健壮性： 有些老的C++代码可能没有使用try...catch，或者只处理了部分异常。SEH可以作为一道额外的防线，避免程序崩溃。
调试： SEH可以提供更详细的异常信息，方便调试。

二、SEH的基本语法和用法

SEH的核心就是四个关键字：__try、__except、__finally和RaiseException。

__try：类似于try，用来包裹可能抛出异常的代码块。
__except：类似于catch，用来捕获并处理异常。
__finally：类似于finally，无论是否发生异常，都会执行的代码块。
RaiseException：用来手动抛出一个异常。

一个简单的SEH例子：

#include <iostream>
#include <windows.h>

int main() {
    int result = 0;
    __try {
        int a = 10;
        int b = 0;
        result = a / b; // 这里会触发除零异常
        std::cout << "This line will not be executed." << std::endl;
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        std::cerr << "Division by zero error occurred!" << std::endl;
        result = -1; // 设置一个错误码
    }
    __finally {
        std::cout << "Finally block executed." << std::endl;
    }

    std::cout << "Result: " << result << std::endl;
    return 0;
}

在这个例子中，a / b会触发一个除零异常。__except块会捕获这个异常，并打印错误信息。__finally块会在最后执行，无论是否发生异常。

__except块里的表达式：Exception Filter

__except后面括号里的表达式叫做Exception Filter（异常过滤器）。它的作用是决定是否处理这个异常。它可以是以下三种值之一：

EXCEPTION_EXECUTE_HANDLER：处理异常。
EXCEPTION_CONTINUE_SEARCH：继续向上层寻找异常处理程序。
EXCEPTION_CONTINUE_EXECUTION：从异常发生的地方继续执行（非常危险，一般不用）。

更复杂一点的Exception Filter：

#include <iostream>
#include <windows.h>

int main() {
    int result = 0;
    __try {
        int* p = nullptr;
        *p = 10; // 触发访问冲突异常
        std::cout << "This line will not be executed." << std::endl;
    }
    __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        std::cerr << "Access violation error occurred!" << std::endl;
        result = -1;
    }
    __finally {
        std::cout << "Finally block executed." << std::endl;
    }

    std::cout << "Result: " << result << std::endl;
    return 0;
}

在这个例子中，我们使用GetExceptionCode()函数来获取异常代码，然后判断是否是EXCEPTION_ACCESS_VIOLATION（访问冲突异常）。如果是，就处理这个异常；否则，就继续向上层寻找处理程序。

__finally块的妙用

__finally块的一个重要作用是资源清理。比如，你在__try块里分配了一些内存，或者打开了一个文件，无论是否发生异常，你都需要在__finally块里释放这些资源，避免内存泄漏或者文件句柄泄漏。

#include <iostream>
#include <windows.h>

int main() {
    HANDLE hFile = INVALID_HANDLE_VALUE;
    __try {
        hFile = CreateFile("test.txt", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (hFile == INVALID_HANDLE_VALUE) {
            RaiseException(GetLastError(), 0, 0, NULL); // 手动抛出异常
        }

        DWORD bytesWritten;
        char buffer[] = "Hello, SEH!";
        if (!WriteFile(hFile, buffer, sizeof(buffer) - 1, &bytesWritten, NULL)) {
            RaiseException(GetLastError(), 0, 0, NULL); // 手动抛出异常
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        std::cerr << "Error occurred: " << GetExceptionCode() << std::endl;
    }
    __finally {
        if (hFile != INVALID_HANDLE_VALUE) {
            CloseHandle(hFile); // 确保文件句柄被关闭
            std::cout << "File handle closed." << std::endl;
        }
    }

    return 0;
}

在这个例子中，我们在__try块里打开了一个文件，并在__finally块里关闭了这个文件。即使CreateFile或者WriteFile失败，抛出了异常，CloseHandle也会被执行，确保文件句柄被关闭。

RaiseException：手动抛出异常

RaiseException函数可以用来手动抛出一个异常。它的原型如下：

VOID RaiseException(
  DWORD dwExceptionCode,      // 异常代码
  DWORD dwExceptionFlags,     // 异常标志
  DWORD nNumberOfArguments,   // 异常参数个数
  const ULONG_PTR *lpArguments // 异常参数
);

dwExceptionCode：异常代码，可以是Windows定义的异常代码（比如EXCEPTION_ACCESS_VIOLATION），也可以是自定义的异常代码。
dwExceptionFlags：异常标志，可以是EXCEPTION_NONCONTINUABLE（表示异常不能继续执行）或者0。
nNumberOfArguments：异常参数个数。
lpArguments：指向异常参数数组的指针。

三、SEH和C++异常的混合使用

SEH和C++异常可以混合使用，但需要注意一些问题。

C++异常可以被SEH捕获： 通过使用/EHa编译器选项，可以将C++异常转换为SEH异常，从而被SEH的__except块捕获。
SEH异常不能被C++的catch捕获： C++的catch块只能捕获C++异常对象，不能直接捕获SEH异常。

一个混合使用的例子：

#include <iostream>
#include <windows.h>

int main() {
    __try {
        try {
            throw std::runtime_error("C++ exception");
        }
        catch (const std::exception& e) {
            std::cerr << "C++ exception caught: " << e.what() << std::endl;
            RaiseException(12345, 0, 0, NULL); // 抛出一个自定义SEH异常
        }
    }
    __except (GetExceptionCode() == 12345 ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        std::cerr << "SEH exception caught: " << GetExceptionCode() << std::endl;
    }

    return 0;
}

在这个例子中，我们先在try...catch块里捕获C++异常，然后用RaiseException抛出一个自定义的SEH异常。外层的__except块会捕获这个SEH异常。

四、SEH的优缺点

优点：

能捕获所有类型的异常： 包括硬件异常和软件异常。
可以作为一道额外的防线： 避免程序崩溃。
提供更详细的异常信息： 方便调试。
资源清理： __finally块可以确保资源被正确释放。

缺点：

平台依赖性： 只能在Windows上使用。
语法比较繁琐： 相比try...catch，SEH的语法稍微复杂一些。
可能影响性能： SEH的异常处理机制可能会带来一定的性能开销。

五、SEH的实际应用场景

处理硬件异常： 比如除零错误、非法内存访问。
兼容老的C/C++代码： 这些代码可能没有使用try...catch。
编写系统级别的程序： 比如驱动程序、系统服务。
调试程序： SEH可以提供更详细的异常信息，方便调试。

六、一些需要注意的点

避免在__except块里做太多的事情： __except块应该只做一些简单的错误处理，比如记录日志、设置错误码。不要在__except块里执行复杂的逻辑，否则可能会导致程序崩溃。
小心使用EXCEPTION_CONTINUE_EXECUTION： 这个值会让程序从异常发生的地方继续执行，但这样做非常危险，可能会导致程序状态不一致，甚至崩溃。一般情况下，应该避免使用这个值。
注意堆栈展开： SEH的堆栈展开和C++异常的堆栈展开不太一样。在使用SEH时，需要特别注意堆栈展开的问题，避免资源泄漏或者程序崩溃。
与 RAII (Resource Acquisition Is Initialization) 的配合： 尽管 SEH 提供了 __finally 块进行资源清理，但 RAII 仍然是 C++ 中管理资源的首选方式。RAII 依赖于对象的生命周期来自动释放资源，即使在发生异常时也能保证资源得到正确释放。结合 SEH 和 RAII 可以提供更强大的异常安全保障。例如，可以使用 RAII 对象在 __try 块中获取资源，并在对象析构函数中释放资源。如果在 __try 块中抛出异常，RAII 对象将被销毁，其析构函数将被调用，从而释放资源。这样，即使 SEH 异常处理程序没有显式地释放资源，RAII 也能确保资源得到正确释放。

七、表格总结

特性	SEH (Structured Exception Handling)	C++ `try...catch`
适用范围	所有异常 (硬件 & 软件)	C++ 异常对象
平台依赖性	Windows 特有	跨平台
底层实现	Windows 内核交互	C++ 异常处理机制
异常过滤器	`EXCEPTION_EXECUTE_HANDLER`, `EXCEPTION_CONTINUE_SEARCH`, `EXCEPTION_CONTINUE_EXECUTION`	`catch` 块类型匹配
资源清理	`__finally` 块	RAII (Resource Acquisition Is Initialization)
编译器选项	`/EHa` (混合使用时)	无需特殊选项
优点	捕获所有异常，额外防线，详细异常信息	跨平台，语法简洁
缺点	平台依赖，语法繁琐，可能影响性能	只能处理 C++ 异常对象

八、一个更复杂的例子：自定义异常处理

#include <iostream>
#include <windows.h>
#include <exception>

// 自定义异常结构体
struct MyExceptionInfo {
    DWORD exceptionCode;
    const char* message;
};

// 自定义异常处理函数
LONG WINAPI MyExceptionHandler(EXCEPTION_POINTERS* ExceptionInfo) {
    MyExceptionInfo* pExceptionInfo = (MyExceptionInfo*)ExceptionInfo->ExceptionRecord->ExceptionInformation[0];

    std::cerr << "Custom Exception Handler:" << std::endl;
    std::cerr << "  Exception Code: 0x" << std::hex << ExceptionInfo->ExceptionRecord->ExceptionCode << std::endl;
    std::cerr << "  Message: " << pExceptionInfo->message << std::endl;

    // 可以选择继续搜索或终止程序
    return EXCEPTION_EXECUTE_HANDLER;
}

int main() {
    // 设置自定义异常处理函数
    SetUnhandledExceptionFilter(MyExceptionHandler);

    __try {
        MyExceptionInfo myInfo;
        myInfo.exceptionCode = 0xDEADC0DE;
        myInfo.message = "This is a custom exception!";

        ULONG_PTR args[1] = { (ULONG_PTR)&myInfo };

        RaiseException(
            myInfo.exceptionCode,
            0, // 标志
            1, // 参数个数
            args // 参数
        );
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        // 这里不会被执行，因为我们使用了 SetUnhandledExceptionFilter
        std::cerr << "SEH exception caught in __except block (this should not happen)." << std::endl;
    }

    return 0;
}

这个例子展示了如何使用 SetUnhandledExceptionFilter 设置一个全局的、自定义的异常处理函数。这个函数会在任何未被 __try/__except 块处理的异常发生时被调用。这样，你可以集中管理程序中所有未处理的异常，并执行一些自定义的操作，比如记录日志、发送错误报告，或者优雅地关闭程序。 SetUnhandledExceptionFilter 函数会替换默认的 Windows 异常处理程序，所以要谨慎使用，并确保你的自定义处理程序能够处理所有可能的异常情况。

总结

SEH是Windows平台下C++编程的一个重要组成部分。掌握它可以让你写出更健壮、更稳定的程序。虽然它有一些缺点，但只要正确使用，就能发挥很大的作用。记住，代码写得好，bug自然少。就算有bug，也能优雅地处理，而不是让程序崩溃给用户看。

希望今天的讲解对大家有所帮助！祝大家编程愉快！

发表回复 取消回复

发表回复取消回复