突破编程_C++_高级教程（异常处理的高级特性）

最新推荐文章于 2024-11-11 22:14:43 发布

breakthrough_01

最新推荐文章于 2024-11-11 22:14:43 发布

阅读量1.2k

点赞数 27

分类专栏：突破编程_C++_高级教程文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/h8062651/article/details/136345655

版权

突破编程_C++_高级教程专栏收录该内容

15 篇文章 8 订阅

订阅专栏

1 异常处理的高级特性

1.1 异常处理的嵌套

在 C++ 中，异常处理是通过 try, catch, throw 关键字来实现的。当在一个 try 块中抛出一个异常时，该异常会被最近的匹配的 catch 块捕获。如果在当前的 try 块或其嵌套的 try 块中没有匹配的 catch 块，那么异常会继续向外层的作用域传播，直到找到匹配的 catch 块或到达程序的顶层。

嵌套异常处理是指在一个 try 块内部有另一个（或多个）try 块。这种情况下，内部的 try 块会首先检查其内部的 catch 块来捕获异常，如果没有找到匹配的 catch 块，异常会传播到外部的 try 块，并检查其 catch 块。

如下为样例代码：

#include <iostream>  
#include <stdexcept>  

int main() 
{
	try {
		try {
			// 尝试执行一些可能会抛出异常的代码  
			throw std::runtime_error("internal error");
		}
		catch (const std::runtime_error& e) {
			// 捕获内部异常并处理  
			std::cout << "internal exception capture: " << e.what() << std::endl;
		}

		// 继续执行其他代码  
		throw std::runtime_error("external error");
	}
	catch (const std::runtime_error& e) {
		// 捕获外部异常并处理  
		std::cout << "external exception capture: " << e.what() << std::endl;
	}

	return 0;
}

上面代码的输出为：

internal exception capture: internal error
external exception capture: external error

在上面代码中，内部的 try 块首先尝试执行可能会抛出异常的代码，并捕获了一个 std::runtime_error 异常。然后它打印了异常信息并继续执行。随后，外部的 try 块也抛出了一个 std::runtime_error 异常，这个异常由外部的 catch块捕获并打印了信息。

注意：如果外部 try 块中的代码再次抛出了与内部 catch 块相同的异常类型，那么更外部 catch 块仍然会捕获这个异常，即使内部 try 块已经处理过同类型的异常。这是因为每个 try 块都是独立的，它们各自负责自己的异常处理。

嵌套异常处理在构建健壮的错误处理机制时非常有用，特别是当需要在不同层次的代码中处理不同类型的异常时。然而，过度使用嵌套异常处理可能会使代码变得复杂且难以阅读和维护，因此应该谨慎使用。

1.2 异常传播与函数返回

在 C++ 中，当函数抛出一个异常时，该函数的正常返回流程会被中断。这意味着，如果异常在函数内部被抛出且没有被该函数的 catch 块捕获，那么该函数不会执行其后的任何代码，包括任何返回语句。这种情况下，函数的返回值是不确定的，因为它实际上并没有执行返回操作。

当异常被抛出时，系统会开始寻找匹配的 catch 块。这个过程称为异常传播（exception propagation）。它会从抛出异常的点开始，逐级向上检查函数调用栈中的每个 catch 块，直到找到一个匹配的 catch 块为止。如果找不到匹配的 catch 块，程序将调用 std::terminate 并终止执行。

由于异常中断了函数的正常返回流程，因此函数可能没有机会执行任何清理工作，比如释放资源或回滚事务。为了解决这个问题，可以使用析构函数和 RAII（Resource Acquisition Is Initialization）技术。当异常被抛出时，能够保证会按照对象构造的相反顺序调用所有已构造的局部对象的析构函数。这确保了即使在异常发生的情况下，资源也能得到正确的释放。

此外，如果函数抛出了一个异常且没有被捕获，那么该函数实际上并没有返回任何值。对于非 void 返回类型的函数，这意味着调用该函数的代码将得到一个未定义的值。因此，在设计函数时，应该考虑到异常可能的情况，并确保在异常发生时，函数不会返回未定义的值或导致程序状态的不一致。

如下是一个没有正确处理异常覆盖返回的例子：

#include <iostream>  
#include <stdexcept>  

int divide(int a, int b) 
{
	if (b == 0) {
		throw std::invalid_argument("Division by zero is not allowed.");
	}
	return a / b;
}

int main() 
{
	int a = 1;
	int b = 0;

	try {
		int res = divide(a, b);
		std::cout << "The result is: " << res << std::endl;
	}
	catch (const std::exception& e) {
		std::cerr << "Exception caught: " << e.what() << std::endl;
	}

	// 后续业务逻辑  
	std::cout << "Continuing with other code..." << std::endl;

	return 0;
}

在上面代码中，divide 函数用于执行除法操作。如果除数为零，它会抛出一个 std::invalid_argument 异常。在 main 函数中，调用了 divide 函数，并捕获可能抛出的异常。

但是 divide 函数并没有正确处理异常覆盖返回，这可能会出现以下问题：

未定义的返回值： 如果 divide 函数抛出异常且没有被捕获，它将不会返回任何值。在上面的例子中，由于我们使用了 try-catch 块来捕获异常，所以 divide 函数实际上会返回一个值（在异常被抛出的情况下，这个值是未定义的）。但是，如果我们没有在 main 函数中使用 try-catch 块，那么 main 函数将接收到一个未定义的返回值。

后续代码的执行： 在上面代码中，即使捕获了异常并打印了错误消息，程序仍会继续执行 main 函数中的后续代码，输出 “Continuing with other code…”。这可能是因为程序员认为，即使发生异常，程序的其他部分仍然可以安全地执行。然而，这取决于具体的应用场景，有时在捕获异常后继续执行后续代码可能不是安全的做法。

资源泄露和状态不一致： 如果 divide 函数在执行除法之前分配了某些资源（如动态内存），那么在异常被抛出时，这些资源可能不会被正确释放，导致资源泄露。此外，如果函数的执行修改了某些全局状态或外部数据结构，那么在异常被抛出后，这些状态可能会保持在一个不一致的状态。

为了避免这种情况，可以采取以下措施：

确保函数在所有执行路径上都有明确的返回值: 这可以通过在函数的末尾添加一个默认的返回语句来实现，以确保即使发生异常，函数也能返回一个有效的值。

使用 noexcept 关键字来标记不会抛出异常的函数: 这告诉编译器该函数是异常安全的，并且如果该函数抛出了异常，程序将调用 std::terminate 并终止执行。这有助于在编译时捕获可能的异常问题。

在函数的catch块中处理异常，并确保在异常处理完毕后返回一个有效的值: 这样，即使发生了异常，函数也能返回一个定义良好的值，而不是一个未定义的值。

1.3 异常安全：如何编写不泄漏资源的代码

在 C++ 中，异常安全（Exception Safety）是一个重要的编程概念，它指的是在异常发生时，程序能够保持其内部状态的一致性，不会出现资源泄露或数据损坏的情况。为了编写不泄露资源的代码，我们需要采取一些措施来确保异常安全。

以下是实现 C++ 异常安全的一些关键步骤：

使用资源获取即初始化（RAII）：
RAII 是一种将资源管理与对象生命周期紧密结合的技术。通过创建对象来管理资源（如内存、文件句柄、数据库连接等），并在对象的析构函数中释放这些资源，可以确保在异常发生时资源得到正确释放。

避免裸指针和手动内存管理：
尽可能使用智能指针（如std::unique_ptr，std::shared_ptr）来管理动态分配的内存。智能指针会在适当的时候自动释放内存，从而减少了内存泄露的风险。

异常安全保证：
函数可以提供不同的异常安全保证等级：
基本保证（Basic Guarantee）：在抛出异常后，程序仍然保持有效状态，但可能回滚到操作开始前的状态。
强保证（Strong Guarantee）：在抛出异常后，程序保持有效状态，并且不会执行任何部分操作。
无泄露保证（No-Leak Guarantee）：即使在抛出异常的情况下，也不会泄露任何资源。

使用拷贝构造函数和赋值操作符的异常安全性：
当实现类的拷贝构造函数和赋值操作符时，要确保它们在异常发生时不会泄露资源。这通常意味着在函数体内使用局部对象来管理资源，并在成功完成操作后再将它们赋值给目标对象。

使用 noexcept 关键字：
如果函数不会抛出异常，可以使用 noexcept 关键字进行标记。这告诉编译器该函数是异常安全的，并允许编译器进行某些优化。

仔细管理全局和静态资源：
全局和静态对象的构造函数和析构函数在程序的生命周期中只执行一次。如果这些构造函数或析构函数抛出异常，可能会导致程序状态不一致。因此，需要确保这些函数是异常安全的。

测试和审查代码：
编写单元测试和集成测试来验证代码的异常安全性。此外，进行代码审查以确保遵循了良好的异常安全实践。

2 异常与资源管理

2.1 使用 RAII（资源获取即初始化）原则

在 C++ 中，RAII（资源获取即初始化）原则是一种强大的技术，用于管理资源并确保在异常发生时不会发生资源泄露。RAII 原则主张将资源的生命周期与对象的生命周期绑定在一起，从而确保当对象被销毁时，其管理的资源也会被适当地释放。

使用 RAII 原则首先需要创建一个类来管理特定的资源。这个类通常会在构造函数中获取（或初始化）资源，并在析构函数中释放资源。这样，当对象离开其作用域或被销毁时，资源将被自动释放：

#include <iostream>  
#include <stdexcept>  

struct MyResource {};

class ResourceHolder 
{
public:
	ResourceHolder() {
		// 获取或初始化资源  
		resource = allocate_resource();
	}

	~ResourceHolder() {
		// 释放资源  
		release_resource(resource);
	}

	// 禁止拷贝构造函数和赋值操作符  
	ResourceHolder(const ResourceHolder&) = delete;
	ResourceHolder& operator=(const ResourceHolder&) = delete;

private:
	MyResource* resource;
	MyResource* allocate_resource() {
		// 分配或初始化资源的代码  
	}
	void release_resource(MyResource* r) {
		// 释放资源的代码  
		delete r;
	}
};

之后，在可能会抛出异常的函数中，使用资源管理类来管理资源。由于资源管理类的析构函数会在对象销毁时自动调用，因此即使在异常发生时，资源也会被正确释放。

void errorThrow() 
{  
    ResourceHolder holder;  
      
    try {  
        // 可能抛出异常的代码  
    } catch (...) {  
        // 异常处理代码  
    }  
      
    // 当holder离开作用域时，其析构函数将自动释放资源  
}

上面的函数的定义说明在其内部使用 RAII 对象来管理资源，即使发生异常，资源也能得到正确释放。

2.2 使用智能指针管理资源

在 C++ 中，智能指针是一种非常有用的工具，用于自动管理动态分配的内存资源，从而避免内存泄露。智能指针是 RAII（资源获取即初始化）原则的一个实践，它们通过在析构函数中自动释放资源来确保资源的正确管理。在异常处理中，智能指针可以确保即使在异常发生时，资源也能被正确释放。

C++11 及其后续版本提供了几种智能指针，包括 std::unique_ptr、std::shared_ptr、std::weak_ptr 等。这些智能指针都有各自的用途和特性。

（1）使用 std::unique_ptr 管理单个资源：
std::unique_ptr是一种独占所有权的智能指针，它负责删除它所指向的对象。当std::unique_ptr离开其作用域或被重置时，它所指向的对象将被自动删除。
如下为样例代码：

#include <iostream>  
#include <stdexcept>  
#include <memory>  

void processData() 
{
	std::unique_ptr<int[]> datas(new int[100]); // 分配动态数组  

	try {
		// 使用data指向的资源进行操作  
		// ...  
	}
	catch (...) {
		// 异常处理  
		// ...  
	}

	// 当 datas 离开作用域时，它会自动删除所指向的数组  
}

（2）使用 std::shared_ptr 管理共享资源：
std::shared_ptr允许多个智能指针共享同一个对象的所有权。当最后一个std::shared_ptr被销毁或重置时，它负责删除所指向的对象。
如下为样例代码：

#include <iostream>  
#include <stdexcept>  
#include <memory>  

struct MyData {};

void shareData() 
{
	std::shared_ptr<MyData> data = std::make_shared<MyData>(); // 使用std::make_shared分配对象  

	try {
		// 使用data指向的资源进行操作  
		// ...  
	}
	catch (...) {
		// 异常处理  
		// ...  
	}

	// 当 data 离开作用域时，如果没有其他 shared_ptr 指向同一个对象，则对象会被自动删除  
}

3 异常处理在实际项目中的应用

3.1 错误处理与异常处理的对比和选择

在 C++ 中，错误处理和异常处理是两种不同的机制，用于处理程序运行时的错误和异常情况。虽然它们有一些重叠之处，但它们在目的、用法和适用场景上有所不同。下面是对错误处理和异常处理的对比和选择的一些指导原则：

错误处理（Error Handling）

（1）目的：
错误处理主要用于检测并处理可预见的错误条件，这些条件通常是程序逻辑的一部分，并且可以通过返回值或错误码来指示。

（2）用法：

使用函数返回值或错误码来指示操作是否成功。
在调用函数后检查返回值或错误码，并根据需要进行错误处理。
可能需要手动释放资源或回滚操作，以处理错误。

如下为一个错误处理的样例代码：

#include <iostream>  

// 定义一个错误码枚举  
enum ErrorCode 
{
	SUCCESS = 0,
	ERROR_INVALID_INPUT,
	ERROR_OUT_OF_RANGE,
	// 其他错误码...  
};

// 一个可能抛出错误的函数  
ErrorCode divide(int a, int b, int& res)
{
	if (b == 0) {
		// 除数为零，返回错误码  
		return ERROR_INVALID_INPUT;
	}

	res = a / b;
	return SUCCESS; // 操作成功，返回成功码  
}

int main() 
{
	int a = 1;
	int b = 0;
	int res = 0;

	// 调用可能抛出错误的函数  
	ErrorCode errorCode = divide(a, b, res);

	// 检查错误码并进行处理  
	if (errorCode != SUCCESS) 
	{
		std::cout << "Calculation error, error code is : " << errorCode << std::endl;
		// 在这里可以执行其他错误处理逻辑，如记录日志、释放资源等  
		return 1; // 返回错误状态码  
	}

	std::cout << "Result: " << res << std::endl;
	return 0; // 返回成功状态码  
}

上面代码的输出为：

Calculation error, error code is : 1

在上面代码中，定义了一个 ErrorCode 枚举来表示不同的错误码。divide 函数执行除法操作，并在除数为零时返回一个错误码。之后在 main 函数中调用 divide 函数并检查返回的错误码。如果错误码不是 SUCCESS ，则输出错误信息并返回错误状态码。否则，输出计算结果并返回成功状态码。
这种错误处理方式可以明确指示操作是否成功，并在出现错误时采取适当的措施。它提供了一种简单而有效的方式来处理可预见的错误条件，同时避免了异常处理机制的开销。

（3）适用场景：