C++异常处理通过try、catch、throw实现结构化错误管理，结合RaiI确保资源安全，提升代码健壮性与可维护性。
C++异常处理的核心在于
try
,
catch
, 和
throw
这三个关键字，它提供了一种结构化的方式来处理程序运行时可能出现的错误，让代码更健壮，也更容易维护。简单来说，
try
块包裹可能抛出异常的代码，
throw
语句用于抛出异常，而
catch
块则负责捕获并处理这些异常。
解决方案
C++的异常处理机制允许程序在运行时遇到错误时，优雅地转移控制流，而不是直接崩溃。这使得程序能够更好地应对意外情况，例如文件未找到、内存不足或网络连接失败等。
try
,
catch
,
throw
的基本用法
立即学习“C++免费学习笔记（深入）”；
首先，我们需要一个
try
块来包含可能抛出异常的代码。如果在
try
块内部（或者在
try
块调用的函数内部）抛出了异常，程序会立即跳转到与该异常类型匹配的
catch
块。
#include <iostream> #include <stdexcept> // 包含标准异常类 int divide(int a, int b) { if (b == 0) { throw std::runtime_error("Division by zero!"); // 抛出异常 } return a / b; } int main() { try { int result = divide(10, 0); // 可能抛出异常 std::cout << "Result: " << result << std::endl; // 如果没有异常，则执行 } catch (const std::runtime_error& error) { std::cerr << "Exception caught: " << error.what() << std::endl; // 处理异常 return 1; // 返回错误码 } std::cout << "Program continues..." << std::endl; // 如果没有异常，或者异常被处理，则执行 return 0; }
在这个例子中，
divide
函数检查除数是否为零。如果是，它会抛出一个
std::runtime_error
类型的异常。
main
函数中的
try
块捕获这个异常，并打印错误信息。如果没有
catch
块，程序将会终止。
抛出异常 (
throw
)
throw
语句用于抛出异常。你可以抛出任何类型的对象，但通常建议抛出从
std::exception
类派生的对象，这样可以更好地利用标准异常处理机制。
throw std::runtime_error("An error occurred!");
捕获异常 (
catch
)
catch
块用于捕获特定类型的异常。你可以有多个
catch
块来处理不同类型的异常。
catch(...)
可以捕获任何类型的异常，但通常不建议这样做，因为它会隐藏具体的错误信息。
try { // ... } catch (const std::runtime_error& error) { std::cerr << "Runtime error: " << error.what() << std::endl; } catch (const std::exception& error) { std::cerr << "General exception: " << error.what() << std::endl; } catch (...) { std::cerr << "Unknown exception!" << std::endl; }
注意
catch
块的顺序很重要。通常，应该先捕获更具体的异常类型，然后再捕获更一般的异常类型。
异常规范 (Exception Specification) – 已弃用
在 C++11 之前，可以使用异常规范来声明函数可能抛出的异常类型。例如：
int myFunction() throw (std::runtime_error, std::bad_alloc);
这意味着
myFunction
函数可能抛出
std::runtime_error
或
std::bad_alloc
类型的异常。但是，异常规范已经被 C++11 弃用，并在 C++17 中移除。现在，建议使用
noexcept
说明符来表示函数不会抛出异常。
int myFunction() noexcept; // 函数不会抛出异常
noexcept
说明符
noexcept
说明符用于声明函数不会抛出异常。这可以帮助编译器进行优化，并提供更强的异常安全性保证。
int myFunction() noexcept { // ... }
如果一个声明为
noexcept
的函数抛出了异常，程序会立即终止（通常调用
std::terminate
）。
C++ 异常处理的优缺点是什么？什么时候应该使用异常，什么时候应该使用错误码？
异常处理的主要优点是它提供了一种清晰、结构化的方式来处理错误，使代码更易于阅读和维护。它也避免了在每个函数调用后都检查错误码的繁琐过程。然而，异常处理也可能导致性能开销，因为它涉及到栈展开（stack unwinding）的过程。
错误码的优点是性能开销较小，因为它只是简单地返回一个表示错误状态的值。然而，使用错误码可能会使代码更难以阅读和维护，因为它需要在每个函数调用后都检查错误码。
那么，何时使用异常，何时使用错误码？
- 异常： 适用于处理无法轻易恢复的错误，例如内存不足、文件未找到等。也适用于在深层嵌套的函数调用中传递错误信息。
- 错误码： 适用于处理可以轻易恢复的错误，例如无效的参数、文件已存在等。也适用于性能敏感的场景，例如嵌入式系统或游戏开发。
C++中如何自定义异常类？自定义异常类应该继承哪个类？
自定义异常类允许我们创建更具描述性的异常类型，从而更好地表达程序中可能出现的特定错误。
如何自定义异常类
自定义异常类通常从
std::exception
类或其派生类继承。
std::exception
类提供了一个标准的异常接口，包括
what()
方法，用于返回异常的描述信息。
#include <iostream> #include <exception> #include <string> class MyException : public std::exception { private: std::string message; public: MyException(const std::string& msg) : message(msg) {} const char* what() const noexcept override { return message.c_str(); } }; int main() { try { // 模拟抛出自定义异常 throw MyException("Something went wrong in MyProgram!"); } catch (const MyException& e) { std::cerr << "Caught an exception: " << e.what() << std::endl; return 1; } catch (const std::exception& e) { std::cerr << "Caught a standard exception: " << e.what() << std::endl; return 1; } catch (...) { std::cerr << "Caught an unknown exception!" << std::endl; return 1; } return 0; }
在这个例子中，
MyException
类继承自
std::exception
类，并添加了一个
message
成员变量来存储异常的描述信息。
what()
方法被重写，返回
message
的内容。
自定义异常类的设计原则
- 继承自
std::exception
或其派生类：
确保你的异常类符合标准的异常接口。 - 提供有意义的错误信息：
what()
方法应该返回清晰、准确的错误描述，方便调试和排错。
- 避免过度设计： 尽量保持异常类简洁，只包含必要的成员变量和方法。
- 考虑异常安全性： 确保你的异常类不会抛出异常，尤其是在析构函数中。
C++的异常处理机制与RAII（Resource Acquisition Is Initialization）原则有什么关系？如何利用RAII来保证异常安全？
RAII 是一种 C++ 编程技术，它将资源的获取与对象的生命周期绑定在一起。当对象被创建时，资源被获取；当对象被销毁时，资源被释放。这可以确保资源总是被正确地释放，即使在发生异常的情况下。
RAII 与异常安全
RAII 是保证异常安全的关键技术。通过使用 RAII，我们可以确保在异常抛出时，资源能够被正确地释放，避免资源泄漏。
#include <iostream> #include <fstream> #include <memory> // 包含 std::unique_ptr class FileWrapper { private: std::unique_ptr<std::ofstream> file; // 使用智能指针管理资源 public: FileWrapper(const std::string& filename) : file(std::make_unique<std::ofstream>(filename)) { if (!file->is_open()) { throw std::runtime_error("Could not open file!"); } } ~FileWrapper() { // 文件会在 FileWrapper 对象销毁时自动关闭 std::cout << "File closed automatically." << std::endl; } void write(const std::string& data) { if (file) { *file << data << std::endl; } else { throw std::runtime_error("File is not open!"); } } }; int main() { try { FileWrapper myFile("example.txt"); myFile.write("Hello, RAII!"); // 模拟在写入后抛出异常 throw std::runtime_error("Simulated error!"); } catch (const std::exception& e) { std::cerr << "Exception caught: " << e.what() << std::endl; return 1; } return 0; }
在这个例子中，
FileWrapper
类使用
std::unique_ptr
来管理文件资源。当
FileWrapper
对象被销毁时，
std::unique_ptr
会自动关闭文件，即使在
write
函数抛出异常的情况下。这保证了资源不会泄漏，程序具有异常安全性。
RAII 的优势
- 自动资源管理： 资源在对象生命周期结束时自动释放，无需手动管理。
- 异常安全： 保证在异常抛出时，资源能够被正确地释放，避免资源泄漏。
- 简化代码： 减少了手动资源管理的复杂性，使代码更易于阅读和维护。
总而言之， C++的异常处理机制结合RAII原则，能够显著提升代码的健壮性和可维护性。 理解并合理应用这些机制，是编写高质量C++代码的关键。
评论（已关闭）
评论已关闭