C语言传统的处理错误的方式
在C语言中，错误处理通常依赖于返回值和全局变量的方式。具体有以下几种：
- 返回值： 函数通过返回特定的值来指示是否发生了错误，调用者需要检查该返回值。例如，许多标准库函数会返回0表示成功，非0值表示错误。
- 全局变量 errno： 在发生错误时，许多系统调用会设置一个全局变量
errno，调用者可以在调用后检查这个变量来获取错误的详细信息。 - goto 语句： 通过使用goto语句，可以在函数内部跳转到特定的错误处理代码块，从而简化错误处理逻辑。
- setjmp 和 longjmp： 这两个函数用于实现非局部跳转，使得程序能够从一个点跳转到另一个点，通常用于处理异常情况，但使用时需谨慎，因为它们可能导致资源管理和状态不一致的问题。
以下是一个简单的C语言示例：
#include <stdio.h>
int divide(int a, int b, int *result) {
if (b == 0) {
return -1; // 返回-1表示错误
}
*result = a / b;
return 0; // 成功
}
int main() {
int res;
if (divide(10, 0, &res) != 0) {
printf("Error: Division by zero.\n");
} else {
printf("Result: %d\n", res);
}
return 0;
}
C++异常概念
C++11引入了更为现代化的异常处理机制，旨在提高代码的可靠性和可维护性。异常处理在C++中是通过三个关键字实现的：try、catch和throw。当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。 这些关键字共同构成了一种机制，用于处理程序执行过程中可能发生的错误或异常情况。
- try：
try关键字用于定义一个代码块，该代码块可能会抛出异常。将可能引发异常的代码放在try块中，程序会监视这段代码的执行情况。如果在执行过程中发生了异常，控制权会转移到后续的catch块。
try {
// 可能引发异常的代码
int result = divide(10, 0); // 假设这个函数会抛出异常
}
- throw:
throw关键字用于抛出异常。当程序检测到一个错误条件时，可以使用throw语句来引发一个异常。抛出的异常可以是任何类型，但通常是派生自标准库中的std::exception类。
if (b == 0) {
throw std::invalid_argument("Division by zero condition!");
}
在这个例子中，如果分母为零，程序将抛出一个std::invalid_argument类型的异常。
- catch
catch关键字用于定义处理异常的代码块。它紧随在相应的try块之后，用于捕获和处理在try块中抛出的异常。可以有多个catch块，以处理不同类型的异常。
catch (const std::invalid_argument& e) {
std::cerr << "Caught an exception: " << e.what() << std::endl;
}
如果捕获到一个类型为std::invalid_argument的异常，程序将输出相应的错误信息。
异常的使用
异常的抛出和捕获
异常的抛出和匹配原则：
- 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个
catch的处理代码。 - 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。
- 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被
catch以后销毁。（这里的处理类似于函数的传值返回） catch(...)可以捕获任意类型的异常，问题是不知道异常错误是什么。- 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获，这个在实际中非常实用，我们后面会详细讲解这个。
在函数调用链中异常栈展开匹配原则:
- 首先检查
throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则调到catch的地方进行处理。 - 没有匹配的
catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。 - 如果到达
main函数的栈，依旧没有匹配的，则终止程序。上述这个沿着调用链查找匹配的catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。 - 找到匹配的
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 << "unknown exception" << endl;
}
return 0;
}
异常的重新抛出
double Division(int a, int b)
{
// 当b == 0时抛出异常
if (b == 0)
{
throw "Division by zero condition!";
}
return (double)a / (double)b;
}
void Func()
{
// 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
// 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再
// 重新抛出去。
int* array = new int[10];
try {
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
}
catch (...)
{
cout << "delete [] " << array << endl;
delete[] array;
throw;
}
// ...
cout << "delete []" << array << endl;
delete[] array;
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
return 0;
}
Division函数接受两个整型参数a和b，并返回它们的商。如果b为0，则抛出一个C风格的字符串异常。
如果在Division函数中发生了除零异常，它会被抛出。在catch块中，我们首先输出一条消息，表示要释放array内存。然后手动释放array的内存。最后,我们再次抛出异常,让外层的调用者处理。
在main函数中,我们用try-catch块包裹对Func的调用。如果Func抛出异常,它会被main函数捕获并处理。
异常安全
- 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化
- 析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)
- C++中异常经常会导致资源泄漏的问题，比如在
new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，**C++**经常使用RAII来解决以上问题，关于RAII我们智能指针这节进行讲解。
异常规范
1. 异常规格说明：
- 目的：异常规格说明的主要目的是让函数的使用者了解该函数可能抛出的异常类型。这有助于调用者在使用函数时进行适当的错误处理。
- 语法：
使用throw(类型) 来列出函数可能抛出的所有异常类型。例如：
void fun() throw(A, B, C, D);
这表示 fun 函数可能抛出 A、B、C 或 D 中的某种类型的异常。
2. 不抛出异常的声明：
- 如果函数后面接
throw()，则表示该函数不会抛出任何异常。例如：
void* operator delete(std::size_t size) throw();
这表示重载的 delete 操作符不会抛出异常。
3. 无异常接口声明:
- 如果没有异常接口声明，则该函数可以抛出任何类型的异常。也就是说，默认情况下，函数没有指定异常类型时，编译器将允许其抛出任何未被捕获的异常。
4. C++11中的noexcept:
- 在C++11中，引入了
noexcept关键字，用于替代动态异常声明（如throw()）。使用noexcept可以更明确地指示一个函数不会抛出异常。例如：
void thread() noexcept;
如果一个被声明为 noexcept 的函数在运行时抛出了异常，程序将调用 std::terminate()，直接终止程序，而不是通过常规的异常处理机制。
5. noexcept与throw的区别:
- 效率：使用
noexcept可以让编译器进行更多优化，因为它知道该函数不会抛出异常。相比之下，使用传统的throw()声明会引入运行时检查，影响性能。 - 编译时检查：
noexcept提供了编译时检查，允许开发者在编写模板代码时更好地控制是否会抛出异常。
示例：
- 可能抛出特定异常：
void* operator new(std::size_t size) throw(std::bad_alloc);
- 不抛出任何异常：
void* operator delete(std::size_t size) throw();
- C++11中的noexcept：
void func() noexcept; // 表示这个函数不会抛出任何异常
自定义异常体系
实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了。
自定义异常体系的目的
在软件开发中，尤其是复杂系统的开发中，使用自定义异常体系可以帮助团队规范化异常管理。这种做法有助于：
- 统一异常处理： 通过定义一套继承体系，所有抛出的异常都是特定基类的派生类，这样外层调用者可以通过捕获基类来处理所有相关的异常。
- 提高可读性和可维护性： 使用自定义异常可以提供更具体的错误信息，使得代码的可读性和可维护性得到提升。
自定义异常类的设计:
下面是一个简单的自定义异常体系示例：
class Exception {
public:
Exception(const string& errmsg, int id)
: _errmsg(errmsg), _id(id) {}
virtual string what() const {
return _errmsg;
}
protected:
string _errmsg;
int _id;
};
class SqlException : public Exception {
public:
SqlException(const string& errmsg, int id, const string& sql)
: Exception(errmsg, id), _sql(sql) {}
virtual string what() const {
return "SqlException: " + _errmsg + " -> " + _sql;
}
private:
const string _sql;
};
class CacheException : public Exception {
public:
CacheException(const string& errmsg, int id)
: Exception(errmsg, id) {}
virtual string what() const {
return "CacheException: " + _errmsg;
}
};
class HttpServerException : public Exception {
public:
HttpServerException(const string& errmsg, int id, const string& type)
: Exception(errmsg, id), _type(type) {}
virtual string what() const {
return "HttpServerException: " + _type + ": " + _errmsg;
}
private:
const string _type;
};
- 基类 Exception：这是所有自定义异常的基类，包含错误信息和错误ID。它提供了一个虚函数
what()，用于返回错误信息。 - 派生类：如
SqlException、CacheException和HttpServerException继承自Exception类，并重写了what()函数，以提供更具体的错误信息。这使得不同类型的异常能够传递其特定上下文信息。
抛出和捕获自定义异常:
在实际使用中，可以在函数中抛出这些自定义异常，例如：
void SQLMgr() {
srand(time(0));
if (rand() % 7 == 0) {
throw SqlException("权限不足", 100, "select * from name = '张三'");
}
}
void CacheMgr() {
srand(time(0));
if (rand() % 5 == 0) {
throw CacheException("权限不足", 100);
} else if (rand() % 6 == 0) {
throw CacheException("数据不存在", 101);
}
SQLMgr();
}
void HttpServer() {
srand(time(0));
if (rand() % 3 == 0) {
throw HttpServerException("请求资源不存在", 100, "get");
} else if (rand() % 4 == 0) {
throw HttpServerException("权限不足", 101, "post");
}
CacheMgr();
}
在主函数中捕获异常:
在主函数中，可以通过捕获基类 Exception 来处理所有类型的自定义异常：
int main() {
while (1) {
this_thread::sleep_for(chrono::seconds(1));
try {
HttpServer();
} catch (const Exception& e) { // 捕获父类对象
cout << e.what() << endl; // 输出具体的错误信息
} catch (...) {
cout << "Unknown Exception" << endl;
}
}
return 0;
}
总结
- 统一管理：通过自定义异常体系，可以统一管理项目中的所有异常，使得代码更整洁。
- 多态性：利用多态性，调用者只需捕获基类对象即可处理所有派生类对象，提高了代码的灵活性。
- 可扩展性：如果需要添加新的异常类型，只需创建新的派生类，而不需要修改现有代码，符合开放-关闭原则（OCP）。
C++标准库的异常体系
C++ 提供了一系列标准的异常，定义在 <exception> 头文件中，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的，主要包括以下几种类型：
| 异常类 | 描述 |
|---|---|
| std::bad_alloc | 通常由 new 操作符抛出，表示内存分配失败。 |
| std::bad_cast | 通常由 dynamic_cast 抛出，表示类型转换失败。 |
| std::bad_typeid | 通常由 typeid 抛出，表示类型信息不可用。 |
| std::domain_error | 当使用数学上无效的域时抛出。 |
| std::invalid_argument | 当函数接收到无效参数时抛出。 |
| std::length_error | 当创建一个过大的 std::string 时抛出。 |
| std::out_of_range | 当访问超出范围的元素时抛出，例如使用 at 方法时。 |
| std::overflow_error | 当发生数学溢出时抛出。 |
| std::underflow_error | 当发生数学下溢时抛出。 |
| std::logic_error | 表示逻辑错误，例如传递了无效参数。 |
| std::runtime_error | 表示运行时错误，例如无法打开文件或内存耗尽等。 |
| std::ios_base::failure | 表示输入输出操作失败的异常，通常与流操作相关。 |
| std::future_error | 在处理 std::future 和 std::promise 时违反预条件时抛出。 |
自定义异常：
除了使用标准异常外，开发者还可以通过继承 std::exception 或其子类来创建自定义异常。这种方式允许开发者封装详细的错误信息，并提供上下文特定的错误消息。
示例：自定义异常类
#include <exception>
#include <string>
class MyException : public std::exception {
public:
explicit MyException(const std::string& msg) : message(msg) {}
const char* what() const noexcept override {
return message.c_str();
}
private:
std::string message;
};
异常的优缺点
C++异常的优点：
异常处理在C++中提供了一种比传统错误码更优雅和灵活的错误管理方式。
-
清晰准确的信息展示
丰富的错误信息：异常对象可以包含详细的错误信息，包括错误类型、错误描述、堆栈调用信息等。这使得开发者能够更容易地定位和修复程序中的bug。 -
简化错误处理流程
- 直接跳转到错误处理：使用异常时，无论在哪个层级的函数发生错误，异常会自动传播到调用链的最外层，直接跳转到 catch 块进行处理。这样，开发者不需要在每个函数中检查返回值并逐层返回错误，简化了代码结构。
//需要逐层返回错误码
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;
}
- 异常体系的优势：如果是异常体系，不管是
ConnnectSql还是ServerStart及调用函数出错，都不用检查，因
为抛出的异常异常会直接跳到main函数中catch捕获的地方，main函数直接处理错误。
- 与第三方库的兼容性
广泛支持：许多常用的第三方库（如Boost、Google Test、Google Mock等）都使用异常来处理错误。因此，使用这些库时，采用异常处理机制可以确保与库的良好兼容性。 - 特殊情况的处理
构造函数和无返回值函数：某些函数（例如构造函数）没有返回值，这使得通过返回值来表示错误变得不方便。在这种情况下，使用异常是更好的选择。例如，越界访问操作符（如T& operator[]）可以通过抛出异常来处理，而不是通过返回值来表示错误。
C++异常的缺点：
- 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。
- 异常会**有一些性能的开销。**当然在现代硬件速度很快的情况下，这个影响基本忽略不计。
- C++没有垃圾回收机制，资源需要自己管理。 有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用
RAII来处理资源的管理问题。学习成本较高。 - **C++**标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。
- 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都使用
func（） throw();的方式规范化。
总结：异常总体而言，利大于弊，所以工程中我们还是鼓励使用异常的。另外OO的语言基本都是用异常处理错误，这也可以看出这是大势所趋。
扫一扫
288
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
