C++ 异常处理机制与自定义异常体系

目录

1.C语言传统的处理错误的方式 ??

1. 终止程序

2. 返回错误码

3.实际使用中的情况

2. C++异常概念??

2.1 C++异常的基本概念

2.2异常的抛出和匹配原则

2.3?异常的重新抛出

2.4 异常安全

2.5 异常规范

3. 自定义异常体系 ???

3.1??自定义异常类

3.2??自定义多个异常类型

3.3. 捕获自定义异常

3.4 异常层次结构设计

4.C++标准库的异常体系 ???

5.异常的优缺点???

---

前言???

在程序开发中，错误和异常的处理是至关重要的，它直接影响到程序的健壮性和稳定性。C语言的错误处理主要依赖返回值和错误码，虽然这种方式简单直接，但在复杂的程序中，错误处理代码往往难以维护且**容易出错。**相比之下，C++引入的异常处理机制提供了一种更为高效和灵活的错误处理方式，使得程序的错误管理更加清晰和优雅。

本节将详细介绍C++异常处理的相关概念、用法以及如何通过自定义异常体系来满足程序的需求。同时，我们将对比C语言的传统错误处理方式，分析C++异常机制的优缺点，并探讨标准库中提供的异常体系，帮助开发者更好地理解和使用C++的异常处理功能。

1.C语言传统的处理错误的方式 ??

C语言传统的错误处理机制主要有两种方式：终止程序和返回错误码。这两种方式虽然简单易用，但各自也有其局限性和缺陷，尤其是在处理复杂错误或大规模程序时，往往会导致维护上的困难。

1. 终止程序

一种常见的错误处理方式是直接终止程序，这种方式通常是通过使用**assert宏实现的。assert**会在程序运行时对条件进行检查，如果条件不满足，则程序会立即终止并输出错误信息。

代码如下：

#include <assert.h>void foo(int x) {assert(x != 0);  // 如果x为0，程序终止printf("x is not zero
");
}int main() {foo(0);  // 触发断言，程序终止return 0;
}

缺陷：

• 用户难以接受：程序直接终止，尤其是当发生一些小错误或边界条件时，用户体验很差。
• 适用场景有限：这种方式适用于严重错误（如内存错误、除0错误等），但不适合所有情况，因为大多数程序错误并不需要完全终止程序。

当程序遇到无法恢复的错误时，**assert**可以有效地帮助开发者检测出问题。但是，当程序出现一些非致命错误时，用户希望程序能够优雅地处理，而不是直接崩溃。

2. 返回错误码

另一个常见的错误处理方式是通过返回错误码来通知程序出现了问题。这种方法在C语言中非常普遍，许多标准库函数**（如malloc、fopen等**）都通过返回一个特殊的错误码来表示函数执行失败。开发者需要根据返回值来判断错误，并做相应的处理。

比如，malloc在分配内存失败时返回NULL，fopen在打开文件失败时返回NULL，errno则是一个全局变量，用于记录最近一次系统调用的错误码。

缺陷：

• 需要手动检查错误码：程序员必须检查每个函数调用的返回值，以便发现错误。这导致了大量重复的错误处理代码，增加了维护成本。
• 错误信息不够直观：虽然可以通过errno来获取详细的错误信息，但这通常不如异常机制直观。错误码本身通常是数字，缺乏对错误本质的描述，需要额外的逻辑去理解错误码的含义。
• 错误处理分散：程序中多处调用的函数可能会返回不同的错误码，处理这些错误的逻辑往往分散在代码的各个地方，导致代码的可读性差。

3.实际使用中的情况

在实际的C语言开发中，返回错误码是最常见的错误处理方式。C语言没有内建的异常机制，所以程序员必须通过检查每个函数调用的返回值来手动处理错误。对于一些简单的错误，返回错误码通常足够。但对于较复杂的应用程序，错误码的使用可能变得冗长且难以维护。

在一些非常严重的错误情况下（如内存分配失败、文件操作失败等），开发者有时会选择直接终止程序。例如，在发现内存分配失败时，程序可能无法继续执行，这时直接通过exit()或其他方式终止程序可以避免进一步的错误。

2. C++异常概念??

C++的异常机制是一种专门用于处理错误和特殊情况的机制，可以在程序运行时中断当前的控制流，并跳转到一个可以处理该错误的代码块。这种机制使得程序能够优雅地应对各种错误，而不是像C语言那样依赖返回错误码或直接终止程序。

2.1 C++异常的基本概念

1. 异常 (Exception)

   • 异常是指程序在运行时遇到的一种错误或意外情况，这种情况可能会导致程序无法正常继续执行。
   • 异常通过throw关键字抛出，表示错误已经发生。
   • 异常可以是任意的C++对象**（如数字、字符串、自定义类对象）**，但通常建议使用标准库中的异常类（如std::exception及其派生类）。

2. 异常处理机制 C++通过三种关键字实现异常处理：

   • try：定义一个代码块，用于包含可能发生异常的代码。
   • throw：在异常发生时，用于抛出异常。
   • catch：捕获异常，并定义如何处理它。

2.2异常的抛出和匹配原则

1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。

2. 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。

3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，

所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似

于函数的传值返回）

4. catch(…)可以捕获任意类型的异常，问题是不知道异常错误是什么。

5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，

使用基类捕获，这个在实际中非常实用，我们后面会详细讲解这个。

在函数调用链中异常栈展开匹配原则

1**. 首先检查throw本身是否在try块内部**，如果是再查找匹配的catch语句。如果有匹配的，则

调到catch的地方进行处理。

2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。

3. 如果到达main函数的栈**，依旧没有匹配的，则终止程序**。上述这个沿着调用链查找匹配的

catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(…)捕获任意类型的异

**常，**否则当有异常没捕获，程序就会直接终止。

4**. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。**

代码案例：

double Division(int a, int b)
{
// 当b == 0时抛出异常
if (b == 0)
throw "Division by zero condition!";
else
return ((double)a / (double)b);
}
void Func()
{
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
}
int main()
{
try {
Func();
}
catch (const char* errmsg） {
cout << errmsg << endl;
}
catch(...){
cout<<"unkown exception"<<endl;
}
return 0;
}

这段代码展示了如何在 C++ 中使用异常处理机制来管理错误（特别是除以零的错误）。通过使用 throw 和 catch，程序可以优雅地处理异常，避免崩溃并提供友好的错误信息。虽然当前的异常处理简单直观，但可以进一步改进，采用标准异常类和更多输入验证，以增强代码的健壮性和可维护性。

2.3异常的重新抛出

C++ 异常处理机制中的 异常重新抛出（rethrow）。当捕获到异常时，如果当前函数无法处理异常，或希望更上层的函数处理异常，可以使用 **throw**; 语句重新抛出异常。这种机制允许在当前 catch 块中处理一些必要的操作（如资源释放），然后将异常传递给调用链中的更外层函数进行进一步处理。

代码分析

1. Division 函数

该函数实现了两个整数的除法操作：

• 输入：两个整数 a 和 b。

• 功能：如果 b == 0，抛出一个异常，提示 “除以零错误”。否则，执行除法并返回结果。

  double Division(int a, int b) {
  if (b == 0) // 检查除数是否为零
  throw “Division by zero condition!”; // 抛出异常
  return (double)a / (double)b; // 返回除法结果
  }

2. Func 函数

该函数执行除法操作并演示异常的重新抛出。主要有以下几个步骤：

• 输入：从用户读取两个整数 len 和 time。
• 功能：调用 Division 函数进行除法计算。如果发生除以零错误，则捕获异常并执行一些清理操作（如释放动态分配的内存）。

catch (...) 捕获所有类型的异常。

delete[] array; 释放在 Func 函数中动态分配的内存。

然后，throw; 重新抛出异常，将其传递到 main 函数中的 catch 块处理。

void Func() {int* array = new int[10];  // 动态分配内存try {int len, time;cin >> len >> time;  // 从用户输入获取两个整数cout << Division(len, time) << endl;  // 调用Division进行除法操作} catch (...) {// 捕获所有异常cout << "delete []" << array << endl;delete[] array;  // 释放内存throw;  // 重新抛出异常}// 在异常未发生时释放内存cout << "delete []" << array << endl;delete[] array;
}

3. main 函数

**main 函数包含了一个 try-catch 块，**负责捕获从 Func 函数传递上来的异常：

• 捕获 const char* 类型的异常（即 Division by zero condition! 异常）。

• 打印异常信息。

  int main() {
  try {
  Func(); // 调用Func执行操作
  } catch (const char* errmsg) { // 捕获字符串类型的异常
  cout << errmsg << endl; // 打印异常信息
  }
  return 0;
  }

工作流程与逻辑

1. 执行 main 函数，调用 Func()。
2. 在 Func 中：
   • 从用户输入 len 和 time，调用 Division(len, time) 执行除法。
   • 如果 time == 0，Division 会抛出 "Division by zero condition!" 异常。
   • catch (...) 捕获该异常，并执行异常处理：
     • 打印正在释放的动态数组 array。
     • 释放内存（delete[] array）。
     • 使用 throw; 重新抛出异常，将其交给 main 函数的 catch 块处理。
3. 在 main 中：
   • 捕获到异常 "Division by zero condition!"，并打印该错误信息。

异常的重新抛出

throw; 的作用

• 重新抛出捕获的异常：throw; 可以将当前捕获的异常重新抛出，并将其传递给调用链中的更外层 catch 块进行处理。这使得异常可以被上层函数进一步处理。
• 异常传递：在 catch 中进行一些必要的处理（如资源释放、日志记录等）后，可以选择将异常交给外层的 catch 块进行后续处理。

重新抛出场景

1. 资源清理：在 catch 中执行资源释放、日志记录等操作后，再将异常传递给更外层的函数处理。
2. 中断异常传播：有时候，catch 只需要处理一些临时的错误或简单的资源清理工作，而不关心异常的最终处理，使用 throw; 可以让更外层的 catch 块进行实际的错误处理。
3. 分层处理：复杂的错误处理可以分层执行。内层函数先进行一些清理工作，而具体的错误处理和恢复操作交给外层函数。

总结

1. 异常重新抛出（throw;）是 C++ 异常处理机制中的一种非常有用的功能。它允许捕获的异常在某些情况下继续传递到上层函数，让更上层的代码处理实际的错误。
2. 在本例中，catch 块处理了一些临时的资源清理工作，然后使用 throw; 将异常重新抛出，最终由 main 函数中的 catch 块捕获并输出异常信息。
3. 异常处理中的资源管理（例如内存释放）非常重要，因为它确保即使发生异常，动态分配的资源也能够正确释放，避免内存泄漏等问题。

这种机制可以使异常处理更具灵活性，适应不同层级的错误处理需求，同时保证资源的有效释放。

2.4 异常安全

在 C++ 中，异常安全指的是在出现异常时，确保程序资源管理正确、数据一致性不被破坏。构造函数和析构函数是异常安全的关键点：

1. 构造函数：避免在构造函数中抛出异常，否则对象可能不完全初始化。使用临时对象或函数来避免复杂操作中出现异常。

2. 析构函数：尽量不要在析构函数中抛出异常，因为这可能导致资源泄漏或程序崩溃。如果必须处理异常，捕获并避免传播。

3. 资源管理中的异常：在动态内存分配（new）和锁管理中，异常可能导致内存泄漏或死锁。RAII（资源获取即初始化）模式能自动管理资源，确保异常发生时正确释放资源。

4. 智能指针：使用智能指针（如 std::unique_ptr）可以自动管理内存，避免内存泄漏。

RAII 和智能指针是解决异常安全问题的重要工具，它们通过在对象生命周期内自动管理资源来确保代码的稳定性。

2.5 异常规范

1. 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的

后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。

2. 函数的后面接throw()，表示函数不抛异常。

3. 若无异常接口声明，则此函数可以抛掷任何类型的异常。

// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
// 这里表示这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);
// 这里表示这个函数不会抛出异常
void* operator delete (std::size_t size, void* ptr) throw();
// C++11 中新增的noexcept，表示不会抛异常
thread() noexcept;
thread (thread&& x) noexcept;

3. 自定义异常体系 ???

在 C++ 中，自定义异常体系指的是定义自己的异常类，用于表示特定类型的错误或异常情况。这样可以使异常处理更具可读性和灵活性，方便区分不同类型的错误。

3.1自定义异常类

自定义异常类通常继承自标准库中的 std::exception 类，或者更常见的是直接继承自 std::runtime_error 或 std::logic_error。

基本步骤：

1. 继承 std::exception 或其子类：自定义异常类应继承自 std::exception 或 std::runtime_error，并重写构造函数来传递错误消息。

2. 添加构造函数和成员函数：可以添加自定义的构造函数，用来初始化异常信息。

   #include
   #include
   #include

   // 自定义异常类，继承自 std::runtime_error
   class MyException : public std::runtime_error {
   public:
   MyException(const std::string& message)
   : std::runtime_error(message) {} // 调用基类构造函数
   };

   void testFunction() {
   throw MyException(“Something went wrong!”);
   }

   int main() {
   try {
   testFunction();
   } catch (const MyException& e) {
   std::cout << "Caught MyException: " << e.what() << std::endl;
   } catch (const std::exception& e) {
   std::cout << "Caught std::exception: " << e.what() << std::endl;
   }
   return 0;
   }

3.2自定义多个异常类型

可以创建不同的异常类型来表示不同的错误情境。每种异常类型可以有不同的错误信息，或不同的逻辑处理

class FileNotFoundException : public std::runtime_error {
public:FileNotFoundException(const std::string& filename): std::runtime_error("File not found: " + filename), filename(filename) {}const std::string& getFilename() const { return filename; }private:std::string filename;
};class InvalidInputException : public std::invalid_argument {
public:InvalidInputException(const std::string& message): std::invalid_argument(message) {}
};// 使用示例
try {throw FileNotFoundException("data.txt");
} catch (const FileNotFoundException& e) {std::cout << e.what() << " Filename: " << e.getFilename() << std::endl;
}

3.3. 捕获自定义异常

在 try-catch 块中捕获自定义异常时，应该使用适当的异常类型捕获，确保正确处理特定的错误。

try {throw InvalidInputException("Invalid input provided");
} catch (const InvalidInputException& e) {std::cout << "Caught InvalidInputException: " << e.what() << std::endl;
} catch (const std::exception& e) {std::cout << "Caught a generic exception: " << e.what() << std::endl;
}

3.4 异常层次结构设计

• 基类：std::exception 或 std::runtime_error 用作基类，定义通用的接口（如 what()）。
• 子类：可以为每种具体错误类型创建子类，继承基类并扩展功能。

这种设计方式使得异常体系更加清晰、可扩展。

总结

自定义异常体系的核心是通过继承现有的异常类（如 std::exception 或 std::runtime_error）来创建符合特定需求的异常类型。这样可以方便地进行异常区分，帮助编写更具表现力和可维护性的代码。

4.C++标准库的异常体系 ???

C++ 提供了一系列标准的异常，定义在 中，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的，如下所示：

说明：实际中我们可以可以去继承exception类实现自己的异常类。但是实际中很多公司像上面一样自己定义一套异常继承体系。因为C++标准库设计的不够好用

int main()
{
try{
vector<int> v(10, 5);
// 这里如果系统内存不够也会抛异常
v.reserve(1000000000);
// 这里越界会抛异常
v.at(10) = 100;
}
catch (const exception& e) // 这里捕获父类对象就可以
{
cout << e.what() << endl;
}
catch (...)
{
cout << "Unkown Exception" << endl;
}
return 0;
}

5.异常的优缺点???

C++异常的优点：

1. 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包

含堆栈调用的信息，这样可以帮助更好的定位程序的bug。

2. 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那

么我们得层层返回错误，最外层才能拿到错误，具体看下面的详细解释。

// 1.下面这段伪代码我们可以看到ConnnectSql中出错了，先返回给ServerStart，
ServerStart再返回给main函数，main函数再针对问题处理具体的错误。
// 2.如果是异常体系，不管是ConnnectSql还是ServerStart及调用函数出错，都不用检查，因
为抛出的异常异常会直接跳到main函数中catch捕获的地方，main函数直接处理错误。
int ConnnectSql()
{
// 用户名密码错误
if (...)
return 1;
// 权限不足
if (...)
return 2;
}
int ServerStart() {
if (int ret = ConnnectSql() < 0)
return ret;
int fd = socket()
if（fd < 0）
return errno;
}
int main()
{
if(ServerStart()<0)
...
return 0;
}

3. 很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们

也需要使用异常。

4. 部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如

T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回

值表示错误。

C++异常的缺点：

1. 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会

导致我们跟踪调试时以及分析程序时，比较困难。

2. 异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。

3. C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常

安全问题。这个需要使用RAII来处理资源的管理问题。学习成本较高。

4. C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。

5. 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常

规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都

使用 func（） throw();的方式规范化。

总结：异常总体而言，利大于弊，所以工程中我们还是鼓励使用异常的。另外OO的语言基本都是用异常处理错误，这也可以看出这是大势所趋。