当前位置： 首页 > news >正文

【C++】异常

news 来源：原创 2025/5/21 14:46:23

异常是面向对象语法处理错误的一种方式。

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

  1. 返回错误码。缺陷：需要程序员自己去查找对应的错误。如系统的很多库接口函数都是通过把错误码放到errno中，表示错误。
  2. 终止程序。如assert或者exit。缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。

传统的处理错误的方式缺陷举例：

  • 拿到错误码，需要查找错误码表，才知道是什么错误。
  • 如果一个函数是通过返回值拿数据，那么发生错误时就很难处理。
T& operator[](int index)
{
	//如果index超出了容器范围，该如何返回呢？
    //返回错误码，如果要返回的数据恰好是这个错误码的值呢？
}
  • 如果调用的函数栈很深，返回错误码，需要层层处理
int f1()
{
	//...发生错误，返回错误码
    int ret;
    if(ret != 0)
    {
        return ret;
    }
    return 0;
}

int f2()
{
	int ret = f1();
    if(ret != 0)
    {
        return ret;
    }
    return 0;
}

int f3()
{
	int ret = f2();
    if(ret != 0)
    {
        return ret;
    }
    return 0;
}
int  main()
{
	return 0;
}

 面对上面的问题，C++11采用用异常来处理。

举个栗子：

int main()
{
	vector<int> v = { 1,2,3,4,5 };
	for (int i = 0; i <= v.size(); i++)
	{
		cout << v[i] << " ";
		//cout << v.at(i) << " ";
	}
	return 0;
}

v[i]是通过 std::vector 的 operator[] 重载运算符来访问元素的。它不进行边界检查，当使用 v[i] 访问越界位置时，不会抛出异常，但会导致未定义行为进而引发程序崩溃。

int main()
{
	vector<int> v = { 1,2,3,4,5 };
	for (int i = 0; i <= v.size(); i++)
	{
		//cout << v[i] << " ";
		cout << v.at(i) << " ";
	}
	return 0;
}

 

v.at(i) 是 std::vector 提供的成员函数，用于访问指定位置的元素。与 operator[] 不同的是，at() 函数会进行边界检查。当使用 v.at(i) 访问越界位置时，会抛出 std::out_of_range 异常。可以通过 try-catch 块来捕获并处理这个异常，这样能让程序在出现越界访问时以一种可控的方式进行处理。

int main()
{
	try
	{
		vector<int> v = { 1,2,3,4,5 };
		for (int i = 0; i <= v.size(); i++)
		{
			//cout << v[i] << " ";
			cout << v.at(i) << " ";
		}
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

2.异常概念

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

  • 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 块
}

举个栗子：

int Div(int n, int m)
{
    //如果不加处理，会发生除0错误，程序会崩溃
	return n / m;
}
int main()
{
	int n, m;
	cin >> n >> m;
	cout << Div(n, m) << endl;
	return 0;
}

 

 程序运行崩溃。我们来看一下如何使用异常来解决。

3.异常使用

  1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
  2. 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。
  3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（类似于函数的传值返回）
  4. catch(...)可以捕获任意类型的异常，但是不知道异常错误是什么。
  5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获。在实际工程中使用这种方式。

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

  1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则调到catch的地方进行处理。
  2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。
  3. 如果到达main函数的栈，依旧没有匹配的，则终止程序。上述这个沿着调用链查找匹配的catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。
  4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。

使用异常解决上述问题： 

  • 验证异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
int Div(int n, int m)
{
	//a、如果返回错误码，会和返回的结果混淆，可以通过输出型参数来解决，但是都不太实用
	//b、抛异常
	
	//if (m == 0)
	//{
	//	throw(-1);//throw可以抛出任意类型的对象。这里仅仅抛出-1，和返回错误码没区别
	//}
	if (m == 0)
	{
		throw(string("发生除0错误！"));//可以直接抛出异常信息
	}
	return n / m;
}
int main()
{
	try
	{
		int n, m;
		cin >> n >> m;
		cout << Div(n, m) << endl;
	}
	catch (int err)
	{
		cout << "发生除0错误: " << err << endl;
	}
	catch (const string& err)
	{
		cout << err << endl;
	}
}

如果发生了除0错误，throw就会抛出异常，程序直接跳转到catch匹配的地方，执行catch的代码块。如果没有匹配的catch就报错。

  • 验证“被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个”
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <string>
using namespace std;

int Div(int n, int m)
{
	if (m == 0)
	{
		throw(string("发生除0错误！"));//可以直接抛出异常信息
	}
	return n / m;
}
void f1()
{
	int n, m;
	cin >> n >> m;
	cout << Div(n, m) << endl;
}
int main()
{
	try
	{
		f1();
	}
	catch (const string& err)
	{
		cout <<__LINE__<< err << endl;
	}
}

 如果此时f1（）中也捕获异常，那么异常会匹配哪一个catch呢？

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <string>
using namespace std;

int Div(int n, int m)
{
	if (m == 0)
	{
		throw(string("发生除0错误！"));//可以直接抛出异常信息
	}
	return n / m;
}
void f1()
{
	try
	{
		int n, m;
		cin >> n >> m;
		cout << Div(n, m) << endl;
	}
	catch (const string& err)
	{
		cout << __LINE__ << err << endl;
	}
}
int main()
{
	try
	{
		f1();
	}
	catch (const string& err)
	{
		cout <<__LINE__<< err << endl;
	}
}

 会匹配与异常对象类型匹配且离抛出异常位置最近的那一个。

  • 验证“catch(...)可以捕获任意类型的异常，但是不知道异常错误是什么。”
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <string>
using namespace std;

int Div(int n, int m)
{
	if (m == 0)
	{
		throw "发生除0错误";
		//throw(string("发生除0错误！"));
	}
	return n / m;
}
void f1()
{
	try
	{
		int n, m;
		cin >> n >> m;
		cout << Div(n, m) << endl;
	}
	catch (const string& err)
	{
		cout << __LINE__ << err << endl;
	}
}
int main()
{
	try
	{
		f1();
	}
	catch (const string& err)
	{
		cout <<__LINE__<< err << endl;
	}
}

没有与异常类型匹配的catch，报错。

可以使用catch(...)来捕获任意类型的异常：

int Div(int n, int m)
{
	if (m == 0)
	{
		throw "发生除0错误";
		//throw(string("发生除0错误！"));
	}
	return n / m;
}
void f1()
{
	try
	{
		int n, m;
		cin >> n >> m;
		cout << Div(n, m) << endl;
	}
	catch (const string& err)
	{
		cout << __LINE__ << err << endl;
	}
}
int main()
{
	try
	{
		f1();
	}
	catch (const string& err)
	{
		cout <<__LINE__<< err << endl;
	}
	catch (...)//捕获没有匹配的任意类型的异常，避免异常未捕获时程序直接终止。
	{
		//但是不知道捕获的是什么异常
		cout << "未知异常" << endl;
	}
}

可以看到解决了传统的错误处理方式的缺陷。异常可以直接抛出错误异常信息，然后跳到捕获异常的地方。

4.异常的重新抛出

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

举个栗子：

int Div(int n, int m)
{
	if (m == 0)
	{
	    throw(string("发生除0错误！"));
	}
	return n / m;
}
void f1()
{
	int* arry = new int[10];
	int n, m;
	cin >> n >> m;
	cout << Div(n, m) << endl;

	cout << "delete []" << arry << endl;
	delete[] arry;
}
int main()
{
	try
	{
		f1();
	}
	catch (const string& err)
	{
		cout << err << endl;
	}
}

 如果此时发生了除0错误，那么程序将会跳到catch地方执行catch代码块，delete[] arry未执行，arry得不到释放，会造成内存泄漏的问题。

解决方式：异常重新抛出。

int Div(int n, int m)
{
	if (m == 0)
	{
	    throw(string("发生除0错误！"));
	}
	return n / m;
}
void f1()
{
	int* arry = new int[10];
	try
	{
		int n, m;
		cin >> n >> m;
		cout << Div(n, m) << endl;
	}
	catch (...)//可以以任意类型捕获异常，这里捕获了并不处理异常，还是交给外面处理。捕获了再抛出去
	{
		cout << "delete[] " << arry << endl;
		delete[] arry;
		throw;
	}
}
int main()
{
	try
	{
		f1();
	}
	catch (const string& err)
	{
		cout << err << endl;
	}
}

5.异常安全

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

6.异常规范

  • 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。

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

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

//new/lock/fopen
//
//fun();//如果这里抛异常，会导致异常安全问题
//
//delete/unlock/fclose


// 这里表示这个函数可以抛出任意类型的异常
void fun();
// 这里表示这个函数会抛出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;
void* operator delete (std::size_t size, void* ptr) noexcept;

​

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

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

 举个栗子：

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

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

 7.自定义异常体系

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

举个栗子：

//一般来说公司会给一个基类要求你可以抛自己定义的异常，但是必须继承这个基类
//这样以来，外层捕获只需要捕获基类就可以
class Exception
{
public:
	Exception(const char* errmsg, int errid)
		:_errmsg(errmsg)
		, _errid(errid)
	{}
	virtual string what() = 0;
protected:
	int _errid;          //错误码
	string _errmsg;      //错误描述
	//stack<string> _st; //调用堆栈
};
class SqlException : public Exception
{
public:
	SqlException(const char* errmsg, int errid)
		:Exception(errmsg, errid)
	{}
	virtual string what()
	{
		return "数据库错误:" + _errmsg;
	}
};
class NetworkException : public Exception
{
public:
	NetworkException(const char* errmsg, int errid)
		:Exception(errmsg, errid)
	{}

	virtual string what()
	{
		return "网络错误:" + _errmsg;
	}
};

void ServerStart()
{
	//模拟出问题抛异常
	if (rand() % 9 == 0)
		throw SqlException("数据库启动失败", 1);
	if (rand() % 7 == 0)
		throw NetworkException("网络连接失败", 3);
	cout << "正常运行" << endl;
}

int main()
{
	for (int i = 0; i < 100; i++)
	{
		try
		{
			ServerStart();
		}
		catch (Exception& e)//抛子类，父类捕获
		{
			cout << e.what() << endl;//多态，指向e指向谁调用谁的what
		}
		catch (...)
		{
			cout << "未知异常" << endl;
		}
	}
	
	return 0;
}

8.异常优缺点

优点：

  1. 相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。
  2. 面对需要有返回值的函数如T operator[](int i)这样的函数越界错误，异常可以很好的解决。
  3. 函数多层调用时，发生错误，不需要层层返回处理，使抛异常直接在最外层直接捕获即可。
  4. 很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们也需要使用异常。

缺点：

  1. 异常会导致执行流混乱。会给调试分析程序bug带来困难。
  2. C++没有垃圾回收机制，异常可能会导致资源泄漏等异常安全问题。需要学号使用RAII解决。
  3. C++的标准库的异常体系定义的不好，导致大家各自定义各自的异常体系，非常的混乱。
  4. C++的异常语言可以抛任意类型的异常，如果项目中没有做很好的规范管理，会非常的混乱，所以一般需要定义出继承体系的异常规范，或者明确函数是否抛异常的方式规范。

总结：异常总体利大于弊，在大型的工程中鼓励使用异常。

相关文章：

  • 基于Canvas和和原生JS实现俄罗斯方块小游戏
  • torch.cat 函数介绍
  • 自然语言处理：Transformer、BERT
  • 数据结构（顺序表）
  • 基于PaddleNLP使用DeepSeek-R1搭建智能体
  • SpringBoot与Sentinel整合，解决DDoS攻击与异常爬虫请求问题
  • 系统思考与问题诊断
  • 【求100-200之间的素数】
  • 支持向量简要理解
  • AF3 squeeze_features函数解读
  • 高效运行 QwQ-32B + 错误修复
  • Ubuntu 下 Docker 企业级运维指南：核心命令与最佳实践深度解析20250309
  • AI Copilot——维新派的贾维斯，守旧派的墓志铭（程序员视角）
  • Synchronized 锁升级过程
  • 推荐一些免费开源支持Vue3甘特图组件
  • Python批量将中文文件名称转为英文、拼音的方法
  • 《基于深度学习的图像修复技术研究与应用-图像修复》—3000字论文模板
  • C++之“string”类的模拟实现
  • 二叉树中的深搜
  • IPFS：下一代互联网传输协议
  • 哪都“差一点”的《歌手2025》，还能爆吗？
  • 外交部：中方支持俄乌直接对话谈判，支持政治解决危机
  • 法国参议院调查委员会公布雀巢“巴黎水”丑闻调查报告
  • 人民日报：不能层层加码，要层层负责
  • 国际观察丨美中东政策生变，以色列面临艰难选择
  • 海外市场，押注中国无人驾驶龙头