【C++高阶(七)】C++异常处理的方式

💓博主CSDN主页:杭电码农-NEO💓

⏩专栏分类:C++从入门到精通⏪

🚚代码仓库:NEO的学习日记🚚

🌹关注我🫵带你学习C++

🔝🔝

异常处理的方式

[1. 前言](#1. 前言)
[2. C语言处理异常的方式](#2. C语言处理异常的方式)
[3. C++异常概念](#3. C++异常概念)
[4. 异常的抛出和匹配原则](#4. 异常的抛出和匹配原则)
[5. 异常的重新抛出](#5. 异常的重新抛出)
[6. RAII思想在异常体系中的使用](#6. RAII思想在异常体系中的使用)
[7. 自定义异常体系](#7. 自定义异常体系)
[8. C++标准库的异常体系](#8. C++标准库的异常体系)
[9. 总结以及拓展](#9. 总结以及拓展)

1. 前言

C++有一套独立的异常处理机制,

相信大家一定听说过try,catch这两

个词,今天就来做详细的介绍

本章重点:

本篇文章着重讲解C++异常处理的方式,
三个关键字,tyr,catch,throw,并且介绍异
常的用法和自定义体系的异常以及智能指
针在异常处理中的使用场景.其中,会复习
C语言异常处理的方式

2. C语言处理异常的方式

最经典的处理方式:使用assert

assert的缺陷:

如果在代码中使用assert,则只在debug
模式下有效,在release模式下会失效.并且
只要有错误就会直接终止程序,这明显不符
合实际,比如说在使用微信时,由于网络问题
信息没发出去,这时直接将微信程序终止了,
这样做会被乱棍打死!

C语言还能用错误码返回异常信息

错误码errno的缺陷:

返回的错误码是一个数字,程序员还需
去查表来得知这个错误码是什么意思,
并且就算查找了错误码的信息,可能它
说的不清楚,也不好看错误信息

综上所述,C语言处理异常的方式还是
不够完美,于是祖师爷写了一套自己的

3. C++异常概念

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

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

使用方法:

cpp 复制代码

try{
	int a,b;
	cin>>a>>b;
	if(b == 0)
		throw "除0错误"
	cout<<(a/b)<<endl;
}

catch(string str)
{
	//......
}

如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码,一旦throw后,会直接跳到catch的位置,后面的代码不会执行

4. 异常的抛出和匹配原则

异常的抛出和匹配有以下机制:

抛出的内容和捕捉的内容要一致

如果你在throw时抛出一个字符串,但是
在catch捕获异常时的参数却写的是整数
那么这个抛出的异常就不会去这个catch

cpp 复制代码

try{
	int a,b;
	cin>>a>>b;
	if(b == 0)
		throw "除0错误"
	cout<<(a/b)<<endl;
}
catch(int flag)//类型与throw的不匹配,会跳到下面的catch
{
	//......
}
catch(string str)
{
	//......
}

try可以嵌套多层

try和catch不仅仅可以在一个作用域
使用,还可以在最外层try,然后嵌套多
层函数,在最里面的函数throw!

cpp 复制代码

void a(){throw "测试中";}
void b(){a()}
void c(){b()}
int main()
{
	try{
		c();
	}
	catch(string str)
	{}

throw和catch遵循就近原则

若写了多个catch,并且这些catch都
和throw的内容匹配,则会跳转到与
throw最近的内个catch中!

cpp 复制代码

double Division(int a, int b)
{
    // 当b == 0时抛出异常
	if (b == 0)
	  throw "除0错误!";
   else
   	  return ((double)a / (double)b);
}
void Func()
{
	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;
	catch (const char* errmsg） {//这个catch与throw相距最近,会优先到这儿
	cout << errmsg << "111" << endl;
	}
}
int main()
{
	try {
		Func();
	}
	catch (const char* errmsg） {
		cout << errmsg << "222" << endl;
	}
	return 0;
}

catch(...)可以捕获任意类型的异常

在公司写大工程的时候,会和很多同事
合作写代码,大家都会抛出异常,但是你
不能确定是不是所有人抛出的类型你都
有相应的catch可以接收,若抛出一个异常
没有被捕获会直接报错,所以...的作用很
明显,用来兜底!一般用于接收一些未知异常

cpp 复制代码

double Division(int a, int b)
{
    // 当b == 0时抛出异常
	if (b == 0)
	  throw "除0错误!";
   else
   	  return ((double)a / (double)b);
}
void Func()
{
	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;
	catch (const char* errmsg） {//这个catch与throw相距最近,会优先到这儿
	cout << errmsg << "111" << endl;
	}
}
int main()
{
	try {
		Func();
	}
	catch (const char* errmsg） {
		cout << errmsg << "222" << endl;
	}
	 catch(...){
   cout<<"未知异常"<<endl;           
    }
	return 0;
}

基类可以接受抛出的子类对象

抛出和捕获有一个例外,那就是可以抛出
子类对象,用基类捕获,这个在实际场景中
非常实用,我们会在后面详谈

5. 异常的重新抛出

有可能在捕获异常时,一次捕获不能

完全解决问题,比如我们想在main函

数中处理所有的异常,在非main函数

中打印一下异常信息然后再将异常抛

到main中统一做处理

cpp 复制代码

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

在上面的场景中,如果抛出异常,就会
直接走到catch处,不会调用delete释放
释放在堆上开辟的空间,就会有问题,所
以第一次catch时先处理释放空间的问题
然后将异常再次抛出后再处理异常问题

6. RAII思想在异常体系中的使用

如果你不知道什么是RAII思想,不知道

什么是智能指针,请先阅读这篇文章:

智能指针RAII思想讲解

在异常体系中在堆上申请空间,或者
打开某个问题时常容易出问题,因为
堆上开辟的空间要显示调用delete处理
而打开的文件也要显示调用fclose关闭
所以一旦发生异常就会直接跳转到catch
的位置,有可能直接忽略了释放函数
这也就是导致了资源并没有被释放!

在异常体系中最好使用RAII思想申请资源
即使抛出异常后直接跳到catch也没问题
当出了对象作用域会自动调用析构释放!

cpp 复制代码

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

7. 自定义异常体系

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

不同的部分可以抛出不同的异常,然后在总的main函数中使用基类捕获所有的异常再来进行特殊的处理

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

这里的内容属于了解范畴,用几张图

带大家了解一下:

实际中都是我们自己去实现一个异常体系
因为C++库做的并不好

9. 总结以及拓展

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

除此之外,异常还有一套规范,因为
比较鸡肋,所以放在了最后来介绍:

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

cpp 复制代码

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

之所以比较鸡肋是因为就算你写了

noexcept,再抛出异常

在某些编译器也不会报错

🔎 下期预告:单例模式&特殊类设计🔍