【C++学习】深入理解C++异常处理机制：异常类型，捕获和处理策略

文章目录

  • ♫一.异常的提出
  • ♫二.异常的概念
  • ♫三.异常的使用
      • ♫3.1 异常的抛出和捕获
      • ♫3.2.异常的重新抛出
      • ♫3.3异常安全
      • ♫3.4 异常规范
  • ♫4.自定义异常体系
  • ♫5.C++标准库的异常体系
  • ♫6.异常的优缺点

♫一.异常的提出

  • 之前：
    C语言传统的处理错误的方式与带来的弊端：
  1. 终止程序。如assert，缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。
  2. 返回错误码。缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通
    过把错误码放到errno中，表示错误实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。但是错误码表里面有很多，去一一查询特别的麻烦，所以就在寻找一种新的解决方法，也就是异常处理。
    错误码表参考http://t.csdnimg.cn/h3H6q
  • 现在：
    提出异常来解决这些弊端…

♫二.异常的概念

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

  1. 使用方法：
    • throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
    • catch: 在想要处理问题的地方，通过异常处理程序捕获异常 catch 关键字用于捕获异常，可以有多个catch进行捕获。如果在main函数都结束了，都没有被捕获，则编译器会报错。
    • try: try 块中的代码标识将被激活的特定异常,它后面通常跟着一个或多个 catch 块。
      如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。使用 try/catch 语句的语法如下所示：
try
{
  // 保护的标识代码
}catch( ExceptionName e1 )
{
  // catch 块
}catch( ExceptionName e2 )
{
  // catch 块
}catch( ExceptionName eN )
{
  // catch 块
}

举个实际的例子：

void func(){
	int x;  cin >> x;
	if (x % 2 == 0)    //当为偶数时，就抛出异常
	{
		throw("异常，x为偶数");  
	}
	cout << x << endl;
}
int main(){
	try {
		func();  //捕获在执行func()时的异常
	}
	catch (const char* x){    
		cout << x << endl;
	}
	return 0;
}

♫三.异常的使用

♫3.1 异常的抛出和捕获

  • 异常的抛出和匹配原则

    1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
      例如： 就比如上面的那个代码，throw 抛出的是一个字符串，那么在catch的时候，应该捕获的是字符串。

      throw(“异常，x为偶数”) 与 catch (const char* x)要匹配

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

//函数ff抛异常后，会在哪一个catch语句被捕获呢？
//根据这个规则首先会看捕获一，但是捕获一的类型不匹配，然后才会去看捕获2与捕获3，
//所以，这里被选中的处理代码是捕获3
void ff()
{
	int x = 0;
	cin >> x;
	if (x % 2 == 0)
	{
		throw(1111111);
	}
}
void  func()
{
	try
	{
		ff();
	}
	catch (const char* s)    //捕获一
	{
		cout <<__LINE__<<" " << s << endl;
	}
}
int main()
{
	try
	{
		func();
	}
	catch (const char* s)  //捕获二
	{
		cout << __LINE__ <<" " << s << endl;
	}
	catch (int x)         //捕获三
	{
		cout << __LINE__ <<" " << x << endl;
	}

	return 0;
}
  1. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）
  2. catch(…)可以捕获任意类型的异常，问题是不知道异常错误是什么。所以为了防止所抛异常没有被处理，在程序最后最好加一个捕获所有。
int main()
{
	try
	{
		func();
	}
	catch (const char* s)  
	{
		cout << __LINE__ <<" " << s << endl;
	}
	catch (int x)         
	{
		cout << __LINE__ <<" " << x << endl;
	}
	catch (...)  //前面的catch语句没有捕获的异常，这里都会被捕获，只是不知道被捕获异常的类型。
	{
		cout << "未知异常" << endl;
	}
	return 0;
}
  1. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获，这个在实际中非常实用，库里面就是这样使用的。（后面会讲到）

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

在这里插入图片描述
如上图：

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

♫3.2.异常的重新抛出

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

举个例子：
第一条catch语句捕获了异常不是为了处理异常，而是为释放掉ptr的内存后，（如果这里不捕获异常的话，则不会执行delete语句，会造成内存泄漏问题），将异常重新抛出，在其他地方去处理这个异常。

void ff(){
	throw("异常");
}
void func(){
	int* ptr = new int[10];
	try {
		ff();
	}
	catch (...){ 
		delete[] ptr;        //抛出之前析构
		throw;      //捕获到什么抛什么
	}
	delete[] ptr;
}
int main(){
	try {
		func();
	}catch (const char* str)   //接受异常处理
	{
		cout << str << endl;
	}
	return 0;
}

♫3.3异常安全

  1. 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化
    例如下面代码：
//在构造对象aa时，调用A类的构造函数，在初始化完ptr1后，调用func函数（这里是故意
//捏造的这个场景，func函数内部会抛异常），就会直接跳到catch语句，这样会致ptr2
//没有被初始化，对象aa不完整。只初始化了一般，另一半是随机值或则是野指针，都是坑。
void func(){
	throw("异常");
}
class A{
public:
	A(){
		cout << "A()" << endl;
		ptr1 = new int;
		func();
		ptr2 = new int;
	}
	~A(){
		cout << "~A()" << endl;
		ptr1 =nullptr;
		ptr2 = nullptr;
	}
private:
	int* ptr1;
	int* ptr2;
};
int main(){
	try{
		A aa;
	}catch (const char* s){
		cout << s << endl;
	}catch (...){
		cout << "未知异常" << endl;
	}
	return 0;
}
  1. 析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)。
    • 析构函数与上面的构造函数类似，如果有抛异常了就会跳到catch语句，可能导致资源没有清理完，造成资源泄漏。
  2. C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题，会在下一个文章专门讲解。
    举个例子：
//当给ptr 开了空间后，调用func函数，导致直接跳转到catch语句，没有完成delete，
//导致内存泄漏问题。
void func(){
	throw("异常");
}
int main(){
	int* ptr;
	try {
		ptr = new int;
		func();
		delete ptr;
	}catch (const char* s){
		cout << s << endl;
	}
	return 0;
}

解决方法：

void func(){
	throw("异常");
}
int main(){
	int* ptr;
	try {
		ptr = new int;
		func();
		delete ptr;   //没有异常清理
	}catch (const char* s){
		delete ptr;     //有异常则在catch语句里面释放
		cout << s << endl;
	}
	return 0;
}

♫3.4 异常规范

  1. 异常规范说明的目的是：为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。
  2. 函数的后面接throw()，表示函数不抛异常。
  3. 若无异常接口声明，则此函数可以抛掷任何类型的异常。
// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
// 这里表示这个函数只会抛出bad_alloc的异常
void* operator new (size_t size) throw (std::bad_alloc);
// 这里表示这个函数不会抛出异常
void* operator delete (size_t size, void* ptr) throw();

// C++11 中新增的noexcept，表示不会抛异常
//不加则表示会抛异常
thread() noexcept;
thread (thread&& x) noexcept;
  • 但是，如果一个函数本来会抛异常，但是后面说明写的是不会抛异常 throw()，编译器也不会报错，只是会提醒。
  • *注意：*编译器指挥检查本函数会不会抛异常，检查不出来该函数内部调用的其他函数是否抛异常。

例子：


void ff()throw(){
	throw("BBBBB");
}
void ff2()throw(const char*){
	cout << "hello" << endl;
}
void ff3()noexcept{
	throw("BBBBB");
}
int main(){
	return 0;
}

在这里插入图片描述

♫4.自定义异常体系

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

例如：

  • Exception是父类，其他都是派生类，并且父类里面的函数what()是虚函数，其他类继承父类，并且添加了需要的其他成员，派生类完成了对what函数的重写，所以在使用中，只需要用父类对象去接受，然后调用what函数即可（父类传给父类，就调用父类的what函数，派生类传给父类，就调用该派生类重写后的what函数）。（这里与库里面的异常体系类似）
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;
};

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

C++ 提供了一系列标准的异常，定义在中，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的，如下所示：
文档链接：https://legacy.cplusplus.com/reference/exception/exception/
在这里插入图片描述
在这里插入图片描述
这里是利用了继承与多态，exception是父类，其他都是派生类，并且父类里面的函数what()是虚函数，其他派生类完成了对what函数的重写，所以在使用中，只需要用父类对象去接受，然后调用what函数即可（父类传给父类，就调用父类的what函数，派生类传给父类，就调用该派生类重写后的what函数）。

使用方法：

int main()
{
	int* p;
	try {
		p = new int[10];
	}
	//用父类对象接受
	catch (const exception& e)  //如果开空间失败，会抛异常（库里面有实现）
	{
		cout << e.what() << endl;  //调用what函数
	}

	return 0;
}

♫6.异常的优缺点

  • C++异常的优点：
    1. 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。
    2. 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误。
    3. 很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们也需要使用异常。
    4. 部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。
T& operator[](size_t pos){
	if (pos < size){
		return _a[pos];
	}
	else{
		//这里越界了应该返回什么呢？
		//0吗，不行，万一_a里面有数据为0呢？
		//所以这里越界就只能终止程序
	}
}
  • C++异常的缺点：
    1. 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。
    2. 异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。
    3. C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题。
    4. C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。
    5. 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常规范有两点：
    • 一、抛出异常类型都继承自一个基类。
    • 二、函数是否抛异常、抛什么异常，都使用 func（） throw();的方式规范化。

本篇完~

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/542504.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【位运算】Leetcode 两整数之和

【位运算】Leetcode 两整数之和

题目解析 371. 两整数之和 算法讲解 异或的本质就是无进位相加&#xff0c;但是我们需要处理进位&#xff0c;就需要知道哪一位上有进位&#xff0c;再让无进位相加的结果 进位即可&#xff0c;在重复这个过程&#xff0c;当进位等于0的时候&#xff0c;说明相加的过程已经结…
阅读更多...
Windows环境下删除MySQL

Windows环境下删除MySQL

文章目录 一、关闭MySQL服务1、winR打开运行&#xff0c;输入services.msc回车2、服务里找到MySQL并停止 二、卸载MySQL软件1、打开控制模板--卸载程序--卸载MySQL相关的所有组件 三、删除MySQL在物理硬盘上的所有文件1、删除MySQL的安装目录&#xff08;默认在C盘下的Program …
阅读更多...
CSS盒模型(详讲)

CSS盒模型(详讲)

目录 概述&#xff1a; 内容区&#xff08;content&#xff09;&#xff1a; 内边距&#xff08;paddingj&#xff09;&#xff1a; 前言&#xff1a; 设置内边距&#xff1a; 边框&#xff08;border&#xff09;&#xff1a; 前言&#xff1a; 示例&#xff1a; 外边…
阅读更多...
飞驰云联入选金融信创生态实验室「金融信创优秀解决方案」

飞驰云联入选金融信创生态实验室「金融信创优秀解决方案」

近日&#xff0c;由中国人民银行领导、中国金融电子化集团有限公司牵头组建的金融信创生态实验室发布了第三期金融信创优秀解决方案&#xff0c;Ftrans飞驰云联“文件数据传输解决方案”成功入选&#xff01; 本次金融信创优秀解决方案遴选经方案征集、方案初审、专家评审等多环…
阅读更多...
unity android 打包

unity android 打包

现在使用的unity版本hub不支持导入support&#xff0c;只能自己下载对应的支持 找到对应的sdk&#xff0c;ndk
阅读更多...
计算机组成原理【CO】Ch2 数据的表示和应用

计算机组成原理【CO】Ch2 数据的表示和应用

文章目录 大纲2.1 数制与编码2.2 运算方法和运算电路2.3 浮点数的表示和运算 【※】带标志加法器OFSFZFCF计算机怎么区分有符号数无符号数? 【※】存储排列和数据类型转换数据类型大小数据类型转换 进位计数制进制转换2的次幂 各种码的基本特性无符号整数的表示和运算带符号整…
阅读更多...
牛客研究生复试刷题（1）

牛客研究生复试刷题（1）

KY30进制转换 1.最开始没有考虑到大数问题，可以说是没考虑完全，输入类型使用的是int64_t，只ac了一半测试用例。所以在数很大找不到合适的数据类型存储时，要考虑使用string来存放。 2.使用string存放数字的时候就要考虑：字符和数字之间的转换。字符转换成数字：str[i]-0，…
阅读更多...
软考125-上午题-【软件工程】-传统软件的测试策略

软考125-上午题-【软件工程】-传统软件的测试策略

一、传统软件的测试策略 有效的软件测试实际上分为4步进行&#xff0c;即&#xff1a;单元测试、集成测试、确认测试、系统测试。 1-1、单元测试&#xff08;模块测试&#xff09; 单元测试也称为模块测试&#xff0c;在模块编写完成且无编译错误后就可以进行。 单元测试侧重…
阅读更多...
ChatGPT-4 Turbo 今天开放啦！附如何查询GPT-4 是否为 Turbo

ChatGPT-4 Turbo 今天开放啦！附如何查询GPT-4 是否为 Turbo

2024年4月12日&#xff0c;OpenAI在X上宣布GPT-4 Turbo开放了&#xff01;提高了写作、数学、逻辑推理和编码方面的能力。另外最重要的是&#xff0c;响应速度更快了&#xff01;&#xff01; ChatGPT4 Turbo 如何升级&#xff1f;解决国内无法升级GPT4 Turbo的问题&#xff0…
阅读更多...
springboot+vue科普知识商城考试论坛交流系统网站

springboot+vue科普知识商城考试论坛交流系统网站

本系统主要是设计出新能源科普网站&#xff0c;基于B/S构架&#xff0c;后台数据库采用了Mysql&#xff0c;可以使数据的查询和存储变得更加有效&#xff0c;可以确保新能源科普网站管理的工作能够正常、高效的进行&#xff0c;从而提高工作的效率。总体的研究内容如下&#xf…
阅读更多...
Nikon | NEF格式图片批量转换为jpg格式

Nikon | NEF格式图片批量转换为jpg格式

如何将nikon相机拍的NEF格式图片转换为jpg格式呢&#xff1f; 这里推荐一个在线转换的网址&#xff1a; https://picflow.com/convert/nef-to-jpg 添加图片后&#xff0c;可以批量选择图片&#xff0c;点击转换后即可进行下载
阅读更多...
【Python】使用OPC UA创建数据服务器

【Python】使用OPC UA创建数据服务器

目录 准备工作服务器设置创建或获取节点设置节点值启动服务器查看服务器客户端总结 在工业自动化和物联网&#xff08;IoT&#xff09;领域&#xff0c;OPC UA&#xff08;开放平台通信统一架构&#xff09;已经成为一种广泛采用的数据交换标准。它提供了一种安全、可靠且独立于…
阅读更多...
Nature Geoscience | 近十年来北方森林和温带森林是全球主要的碳汇

Nature Geoscience | 近十年来北方森林和温带森林是全球主要的碳汇

2023年10月2日&#xff0c;法国巴黎萨克雷大学、波尔多大学与丹麦哥本哈根大学等多个单位的科研小组在国际知名学术期刊《Nature Geoscience》发表了一项题为“Global Increase in Biomass Carbon Stock Dominated by Growth of Northern Young Forests over Past Decade”的文…
阅读更多...
论文笔记：NEFTune: Noisy Embeddings Improve Instruction Finetuning

论文笔记：NEFTune: Noisy Embeddings Improve Instruction Finetuning

iclr 2024 reviewer 评分 5666 1 论文思路 论文的原理很简单&#xff1a;在finetune过程的词向量中引入一些均匀分布的噪声即可明显地提升模型的表现 2 方法评估
阅读更多...
动态规划-简单多状态dp问题2

动态规划-简单多状态dp问题2

文章目录 1. 买卖股票的最佳时机含冷冻期&#xff08;309&#xff09;2. 买卖股票的最佳时机含手续费&#xff08;714&#xff09;3. 买卖股票的最佳时机 III&#xff08;123&#xff09;4. 买卖股票的最佳时机 IV&#xff08;188&#xff09; 1. 买卖股票的最佳时机含冷冻期&a…
阅读更多...
【ELK】ELK企业级日志分析系统

【ELK】ELK企业级日志分析系统

搜集日志&#xff1b;日志处理器&#xff1b;索引平台&#xff1b;提供视图化界面&#xff1b;客户端登录 日志收集者&#xff1a;负责监控微服务的日志&#xff0c;并记录 日志存储者&#xff1a;接收日志&#xff0c;写入 日志harbor&#xff1a;负责去连接多个日志收集者&am…
阅读更多...
年龄与疾病c++

年龄与疾病c++

题目描述 某医院想统计一下某项疾病的获得与否与年龄是否有关&#xff0c;需要对以前的诊断记录进行整理&#xff0c;按照0-18岁、19-35岁、36-60岁、61以上&#xff08;含61&#xff09;四个年龄段统计的患病人数以及占总患病人数的比例。 输入 共2行&#xff0c;第一行为过…
阅读更多...
2440栈的实现类型、b系列指令、汇编掉用c、c调用汇编、切换工作模式、初始化异常向量表、中断处理、

2440栈的实现类型、b系列指令、汇编掉用c、c调用汇编、切换工作模式、初始化异常向量表、中断处理、

我要成为嵌入式高手之4月11日51ARM第六天&#xff01;&#xff01; ———————————————————————————— b指令 标签&#xff1a;表示这条指令的名称&#xff0c;可跳转至标签 b指令&#xff1a;相当于goto&#xff0c;可随意跳转 如&#xff1a;fini…
阅读更多...
Vivado Design Suite中的增量实现和增量模式

Vivado Design Suite中的增量实现和增量模式

Vivado Incremental&#xff08;增量&#xff09;是Xilinx FPGA设计工具中的一种功能&#xff0c;它允许对设计的一部分进行修改和重新编译&#xff0c;而不需要对整个设计进行重新编译。这种增量式的方法可以显著减少编译时间&#xff0c;特别是在进行小的修改或迭代开发时。 …
阅读更多...
粒子群优化算法PSO与鹈鹕优化算法（POA）求解无人机三维路径规划（MATLAB代码）

粒子群优化算法PSO与鹈鹕优化算法（POA）求解无人机三维路径规划（MATLAB代码）

一、无人机路径规划模型介绍 二、算法介绍 close all clear clc dbstop if all error warning (off) global model model CreateModel(); % 创建模型 FF1; [Xmin,Xmax,dim,fobj] fun_info(F);%获取函数信息 pop100;%种群大小(可以自己修改) maxgen100;%最大迭代次数(可以自己…
阅读更多...
最新文章

Copyright @ 2022~2023