【c++】异常

用户11029103

发布于 2025-02-07 09:58:07

33300

代码可运行

文章被收录于专栏：技术学习技术学习

运行总次数：0

代码可运行

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

传统的错误处理机制：

终止程序，如assert，缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。
返回错误码，缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通过把错误码放到errno中，表示错误实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误

2.C++异常

异常是处理错误的一种方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数直接或间接的调用者处理这个错误

throw：当问题出现时，程序会抛出一个异常，这是通过throw关键字完成的
catch: 在想要处理问题的地方，通过异常处理程序捕获异常.catch 关键字用于捕获异常，可以有多个catch进行捕获
try: try 块中的代码标识将被激活的特定异常,它后面通常跟着一个或多个 catch 块

如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。使用 try/catch 语句的语法如下所示

try
{
  // 保护的标识代码
}catch( ExceptionName e1 )
{
  // catch 块
}catch( ExceptionName e2 )
{
  // catch 块
}catch( ExceptionName eN )
{
  // catch 块
}

3.1 异常的抛出和捕获

异常的抛出和匹配原则

异常是通过抛出对象引发的，该对象的类型决定了该激活那个catch的处理码
被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个
抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）

if (b == 0)
{
	string str("Division by zero condition!");
	throw str;
}

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()
{
	try {
		int len, time;
		cin >> len >> time;
		cout << Division(len, time) << endl;
	}
	catch (const char* err)
	{
		cout << err << endl;
	}
	cout << "xxxxxxxxxxxxxx" << endl;
}
int main()
{
	try {
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (...) {
		cout << "unkown exception" << endl;
	}
	return 0;
}

执行顺序分析

main 函数执行：
- 首先执行 try 块，调用 Func() 函数。
Func 函数执行：
- 进入 Func 函数后，执行 try 块。
- 在 try 块中，cin >> len >> time; 读取输入，len 被赋值为 3，time 被赋值为 0。
- 调用 Division(len, time)，即 Division(3, 0)。
Division 函数执行：
- 在 Division 函数中，b == 0，因此会抛出异常 throw "Division by zero condition!";。
- 异常被抛出后，程序控制权返回到 Func 中的 catch (const char* err) 块。
Func 中的异常处理：
- 在 catch (const char* err) 块中，捕获到了异常 "Division by zero condition!"。
- 异常消息被输出：Division by zero condition!。
- 然后，cout << "xxxxxxxxxxxxxx" << endl; 会执行，输出：xxxxxxxxxxxxxx。
main 函数的异常处理：
- Func 函数中已经处理了异常，所以 main 函数中的 catch 块不会再执行，main 函数正常结束。

关键点解释

异常在 Division 函数中被抛出，Func 函数内的 catch 块捕获并处理了这个异常。
因为 Func 已经处理了异常，main 函数的 catch 块不会再被执行。
Func 在处理完异常后继续执行，打印了 "xxxxxxxxxxxxxx"。

3.2 异常的重新抛出

有可能单个的catch不能完全处理一个异常，在进行一些校正处理以后，希望再交给更外层的调用链函数来处理，catch则可以通过重新抛出将异常传递给更上层的函数进行处理

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;
}

Func 函数

void Func()
{
    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* array = new int[10]; 创建一个动态数组，在 Func 结束前需要释放。
调用 Division(len, time)：
- 如果 time == 0，则 Division 抛出异常 "Division by zero condition!"。
catch (...) 捕获所有异常：
- 在 catch 块中，delete[] array; 释放动态数组，防止内存泄漏。
- throw; 重新抛出异常，让 main 处理。

main 函数

int main()
{
    try
    {
        Func();
    }
    catch (const char* errmsg)
    {
        cout << errmsg << endl;
    }
    return 0;
}

try 块调用 Func()，如果 Func 抛出异常，catch (const char* errmsg) 负责捕获它并打印错误信息。

异常被 Func 捕获

catch (...) 捕获所有异常。

cout << "delete []" << array << endl; 先打印内存释放信息：

delete []0x600003fae040

delete[] array; 释放数组。

throw; 重新抛出相同的异常。

异常传递到 main

catch (const char* errmsg) 捕获 throw 重新抛出的异常，并打印错误信息：

Division by zero condition!

main 结束，程序退出。

关键点分析

1. throw; 语句

catch (...) 捕获了所有异常，但不想处理它，而是想让上层 try 处理。
重新抛出异常时，必须使用 throw; 而不是 throw someException;，否则会切断原始异常类型的信息。
由于 throw; 只是重新抛出原始异常，所以 main 中的 catch (const char* errmsg) 仍然可以正确捕获 Division by zero condition!。

2. 资源释放

delete[] array; 确保异常发生时不会造成内存泄漏。
如果 throw; 在 delete[] 之前，程序会泄露 array 的内存。
如果异常没有发生，delete[] 仍然会在 Func 结束时执行，所以无论如何，内存都会被正确释放。

3.3 异常安全

构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化
析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)
C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题

3.4 异常规范

异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。
函数的后面接throw()，表示函数不抛异常。
若无异常接口声明，则此函数可以抛掷任何类型的异常

// 这里表示这个函数会抛出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;

4. 自定义异常体系

实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了

// 服务器开发中通常使用的异常继承体系
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
	{
		string str = "SqlException:";
		str += _errmsg;
		str += "->";
		str += _sql;
		return str;
	}
private:
	const string _sql;
};
class CacheException : public Exception
{
public:
	CacheException(const string& errmsg, int id)
		:Exception(errmsg, id)
	{}
	virtual string what() const
	{
		string str = "CacheException:";
		str += _errmsg;
		return str;
	}
};
class HttpServerException : public Exception
{
public:
	HttpServerException(const string& errmsg, int id, const string& type)
		:Exception(errmsg, id)
		, _type(type)
	{}
	virtual string what() const
	{
		string str = "HttpServerException:";
		str += _type;
		str += ":";
		str += _errmsg;
		return str;
	}
private:
	const string _type;
};
void SQLMgr()
{
	srand(time(0));
	if (rand() % 7 == 0)
	{
		throw SqlException("权限不足", 100, "select * from name = '张三'");
	}
	else
		cout << "调用Sql成功" << endl;
	//throw "xxxxxx";
}
void CacheMgr()
{
	srand(time(0));
	if (rand() % 5 == 0)
	{
		throw CacheException("权限不足", 100);
	}
	else if (rand() % 6 == 0)
	{
		throw CacheException("数据不存在", 101);
	}
	else
		cout << "Cache获取成功" << endl;
	SQLMgr();
}
void HttpServer()
{
	// ...
	srand(time(0));
	if (rand() % 3 == 0)
	{
		throw HttpServerException("请求资源不存在", 100, "get");
	}
	else if (rand() % 4 == 0)
	{
		throw HttpServerException("权限不足", 101, "post");
	}
	CacheMgr();
}
int main()
{
	while (1)
	{
		this_thread::sleep_for(chrono::seconds(1));
		try {
			HttpServer();
		}
		catch (const Exception& e) // 这里捕获父类对象就可以
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (...)
		{
			cout << "Unkown Exception" << endl;
		}
	}
	return 0;
}

这段代码展示了 服务器开发中常见的异常继承体系，它通过 异常类层次结构 以及 多态捕获机制，在 main 函数中统一处理不同类型的异常。

1. 代码的核心目标

设计一个 异常基类 Exception，并让各种子系统（SQL、缓存、HTTP）抛出不同类型的异常。
使用多态机制，通过基类 Exception 统一捕获所有异常，而不需要针对每种异常类型分别处理。
在 HttpServer() 调用链中，异常可能在 SQL、缓存或 HTTP 层抛出，并在 main 中统一捕获。

一、异常类体系设计

class Exception
{
public:
	Exception(const string& errmsg, int id)
		:_errmsg(errmsg)
		, _id(id)
	{}
	virtual string what() const
	{
		return _errmsg;
	}
protected:
	string _errmsg;
	int _id;
};

基类 Exception

成员变量:
- _errmsg（错误信息）
- _id（错误编号）
虚函数 what():
- 允许子类重写，实现自定义异常信息。
- 使用 virtual 关键字，支持多态。

1. SQL 相关异常

class SqlException : public Exception
{
public:
	SqlException(const string& errmsg, int id, const string& sql)
		:Exception(errmsg, id)
		, _sql(sql)
	{}
	virtual string what() const
	{
		string str = "SqlException:";
		str += _errmsg;
		str += "->";
		str += _sql;
		return str;
	}
private:
	const string _sql;
};

特性：

继承自 Exception，用于表示 SQL 相关异常（如权限不足、SQL 语法错误等）。
额外的 _sql 字段 用于存储出错的 SQL 语句。
what() 重新定义：
- 返回 SqlException:权限不足->select * from name = '张三' 这样的格式信息。

2. 缓存系统相关异常

class CacheException : public Exception
{
public:
	CacheException(const string& errmsg, int id)
		:Exception(errmsg, id)
	{}
	virtual string what() const
	{
		string str = "CacheException:";
		str += _errmsg;
		return str;
	}
};

特性：

继承 Exception，表示 缓存相关异常（如数据不存在、权限不足等）。
没有额外字段，仅返回 CacheException:权限不足 这样的格式。

3. HTTP 服务器相关异常

class HttpServerException : public Exception
{
public:
	HttpServerException(const string& errmsg, int id, const string& type)
		:Exception(errmsg, id)
		, _type(type)
	{}
	virtual string what() const
	{
		string str = "HttpServerException:";
		str += _type;
		str += ":";
		str += _errmsg;
		return str;
	}
private:
	const string _type;
};

特性：

继承 Exception，表示 HTTP 服务器异常（如请求资源不存在、权限不足等）。
额外字段 _type，存储 HTTP 请求类型（如 "GET"、"POST"）。
what() 重新定义：
- 返回 "HttpServerException:GET:请求资源不存在" 这样的格式。

二、抛出异常的业务逻辑

1. SQL 相关操作

void SQLMgr()
{
	srand(time(0));
	if (rand() % 7 == 0)
	{
		throw SqlException("权限不足", 100, "select * from name = '张三'");
	}
	else
		cout << "调用Sql成功" << endl;
}

随机模拟 SQL 执行:
- 1/7 概率 抛出 SqlException("权限不足", 100, "select * from name = '张三'")。
- 否则输出 "调用Sql成功"。

2. 缓存管理

void CacheMgr()
{
	srand(time(0));
	if (rand() % 5 == 0)
	{
		throw CacheException("权限不足", 100);
	}
	else if (rand() % 6 == 0)
	{
		throw CacheException("数据不存在", 101);
	}
	else
		cout << "Cache获取成功" << endl;
	SQLMgr();
}

随机模拟缓存异常：
- 1/5 概率 抛出 "权限不足"。
- 1/6 概率 抛出 "数据不存在"。
- 否则 "Cache获取成功" 并继续调用 SQLMgr()（可能导致 SqlException）。

3. HTTP 服务器请求

void HttpServer()
{
	srand(time(0));
	if (rand() % 3 == 0)
	{
		throw HttpServerException("请求资源不存在", 100, "get");
	}
	else if (rand() % 4 == 0)
	{
		throw HttpServerException("权限不足", 101, "post");
	}
	CacheMgr();
}

随机模拟 HTTP 服务器异常：
- 1/3 概率 抛出 "请求资源不存在"（GET）。
- 1/4 概率 抛出 "权限不足"（POST）。
- 否则 继续调用 CacheMgr()，可能导致 CacheException 或 SqlException。

三、异常捕获机制

int main()
{
	while (1)
	{
		this_thread::sleep_for(chrono::seconds(1));  // 每次请求间隔 1s
		try {
			HttpServer();  // 可能抛出 HttpServerException, CacheException, SqlException
		}
		catch (const Exception& e) // 这里捕获父类对象就可以
		{
			cout << e.what() << endl;  // 多态，调用具体异常的 `what()` 方法
		}
		catch (...)
		{
			cout << "Unkown Exception" << endl;
		}
	}
	return 0;
}

执行流程

HttpServer() 可能抛出 HttpServerException，或者调用 CacheMgr()，进而可能抛出 CacheException 或 SqlException。
所有异常都被 catch (const Exception& e) 捕获（多态机制），然后调用 e.what() 打印错误信息。
如果发生未知异常，catch (...) 兜底处理，输出 "Unknown Exception"。
每次循环间隔 1 秒，模拟服务器持续运行。

可能的输出示例

Cache获取成功
调用Sql成功
HttpServerException:post:权限不足
SqlException:权限不足->select * from name = '张三'
CacheException:数据不存在

5. C++标准库的异常体系

C++ 标准库提供了一套完善的异常体系，以处理各种类型的运行时错误和异常情况

基类 std::exception

std::exception 是所有标准库异常的基类。它定义在 <exception> 头文件中，并提供以下成员函数：

class exception {
public:
    exception() noexcept;
    exception(const exception&) noexcept;
    exception& operator=(const exception&) noexcept;
    virtual ~exception();
    
    virtual const char* what() const noexcept;
};

what() 函数返回一个 C 风格字符串，描述异常的具体原因。

标准库异常层次结构

以下是 C++ 标准库中常见的异常派生层次结构：

std::exception
|
|-- std::bad_alloc
|
|-- std::bad_cast
|
|-- std::bad_typeid
|
|-- std::bad_function_call
|
|-- std::bad_weak_ptr
|
|-- std::logic_error
|   |-- std::domain_error
|   |-- std::invalid_argument
|   |-- std::length_error
|   |-- std::out_of_range
|
|-- std::runtime_error
    |-- std::range_error
    |-- std::overflow_error
    |-- std::underflow_error

详细介绍各类异常

1. std::bad_alloc

继承自 std::exception。
当 new 运算符无法分配内存时抛出，表示内存分配失败。

try {
    int* p = new int[1000000000000];
} catch (const std::bad_alloc& e) {
    std::cerr << e.what() << std::endl;
}

2. std::bad_cast

继承自 std::exception。
当 dynamic_cast 转换失败时抛出。

class Base { virtual void dummy() {} };
class Derived : public Base { int a; };

try {
    Base* pBase = new Base;
    Derived* pDerived = dynamic_cast<Derived*>(pBase);  // 失败
    if (!pDerived) throw std::bad_cast();
} catch (const std::bad_cast& e) {
    std::cerr << e.what() << std::endl;
}

3. std::bad_typeid

继承自 std::exception。
当使用 typeid 操作一个指向空对象的指针时抛出。

#include <typeinfo>
try {
    Base* pBase = nullptr;
    std::cout << typeid(*pBase).name() << std::endl;
} catch (const std::bad_typeid& e) {
    std::cerr << e.what() << std::endl;
}

4. std::logic_error

继承自 std::exception。
表示逻辑错误，程序逻辑错误通常可以通过改正代码消除。

派生类

std::domain_error：表示在数学领域上出错的异常。
std::invalid_argument：表示无效参数异常。
std::length_error：表示非法长度异常。
std::out_of_range：表示超出范围异常。

// std::invalid_argument 用例
void check_argument(int arg) {
    if (arg < 0) throw std::invalid_argument("Argument must be non-negative");
}

// std::out_of_range 用例
try {
    std::vector<int> v(5);
    std::cout << v.at(10) << std::endl;  // 越界访问
} catch (const std::out_of_range& e) {
    std::cerr << e.what() << std::endl;
}

5. std::runtime_error

继承自 std::exception。
表示运行时错误，通常指程序运行过程中无法预料的错误。

派生类

std::range_error：表示范围错误异常。
std::overflow_error：表示算术溢出异常。
std::underflow_error：表示算术下溢出异常。

// std::overflow_error 用例
try {
    int result = std::numeric_limits<int>::max();
    result += 1;  // 算术溢出
} catch (const std::overflow_error& e) {
    std::cerr << e.what() << std::endl;
}

// std::underflow_error 用例
try {
    double result = std::numeric_limits<double>::min();
    result /= 2;  // 算术下溢出
} catch (const std::underflow_error& e) {
    std::cerr << e.what() << std::endl;
}

C++11 中的其他异常类

C++11 引入了一些新的标准异常类，用于特定的错误情况：

std::bad_function_call：当调用 std::function 对象指向的函数时，若对象不包含有效的目标函数，则抛出此异常。

try {
    std::function<void()> func;
    func();  // 调用空的 std::function 对象
} catch (const std::bad_function_call& e) {
    std::cerr << e.what() << std::endl;
}

std::bad_weak_ptr：当使用 std::weak_ptr 在所有弱引用的目标对象被销毁时锁定目标对象时抛出。

try {
    std::shared_ptr<int> sp = std::make_shared<int>(10);
    std::weak_ptr<int> wp = sp;
    sp.reset();  // 销毁对象
    std::shared_ptr<int> sp2 = wp.lock();  // 失败
    if (!sp2) throw std::bad_weak_ptr();
} catch (const std::bad_weak_ptr& e) {
    std::cerr << e.what() << std::endl;
}

6.异常的优缺点

C++异常的优点：

异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug
返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误

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;
}

很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们也需要使用异常
部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误

C++异常的缺点：

异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。
异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。
C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题。学习成本较高。
C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。
异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都使用 func（） throw();的方式规范化。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-02-06，如有侵权请联系 cloudcommunity@tencent.com 删除

对象