（十七）错误和异常处理

最新推荐文章于 2023-01-17 22:08:24 发布

dzweather

最新推荐文章于 2023-01-17 22:08:24 发布

阅读量1k

点赞数

分类专栏： C++学习

本文链接：https://blog.csdn.net/dzweather/article/details/8137333

版权

C++学习专栏收录该内容

23 篇文章 0 订阅

订阅专栏

1、异常是一个任意类型的临时变量，用于警示错误。

异常可以是基本类型（int double),但它通常是专门为处理错误而定义的"类对象"．

　　异常对象可以把错误发生的信息传送给处理错误的代码，而且涉及到的信息不只一项．

２、throw 抛出异常一般配合try来使用.

3、try....catch....用于捕捉异常

try块用于可能出现异常的代码,catch用于发生异常后,对异常的捕捉和处理.

catch仅在try产生异常时才执行,.如果没有发生异常,将跳过这个处理 .

try中只要一生成异常, try块异常后的代码交不会执行,直接去catch块去匹配异常.

4..异常处理的过程

一.使用throw表达式将临时对象temp初始化为ExceptionTypetemp(theException);

二.为在try块中声明的所有自动对象调用析构函数.(因为跳出try块,异常就不起作用了,临时变量就起到传递异常的作用)

三.选择参数类型与异常类型的"第一个匹配"的处理程序.

四.使用异常的副本把参数初始化为typeN ex(temp), 并把控制权传递给处理程序.

五. 除非处理程序中的代码决定结束程序,否则在处理程序执行完成后,将跳到整个try块后面(即最后一个catch块的右花括号后)相接代码.

5. 处理中注意的问题:

一.一旦抛出异常,会立即退出try块, 那么在try块中声明的所有自动对象将释放.包括异常本身.

二.异常对象必须是可以复制的.如果异常对象的类拷贝构造函数是私有的(禁止复制),那这个对象就用作异常.

因为离开try时会析构异常对象,这之前会将异常传递给临时变量,再由临时变量去匹配catch,这都会涉及拷贝构造函数.

所以,throw表示式初始化临时时就创建了一个异常的一个副本,这样就可以离开try块,接着使用抛出的副本来初始化catch块的参数,并执行catch块中的处理程序.

三.. catch块也是一个作用域. 执行完catch块,其所有本地自动对象(包括参数)一样要释放.

因此上面的控制权是由try中抛出后,控制权交catch,即使catch代码为空,一样执行完后,再交外层.

6. 重点: 未处理的异常

有两种情况: 一是没有设置捕捉程序产生异常;; 二是虽然设置和捕捉程序(try catch),但漏掉了没捉到. 这都会出现"未处理的异常"

未处理的异常按下面流程执行:

调用标准库函数terminate() (它在<exception>头文件中), 这个函数它会调用预先定义的默认中断处理函数,这个默认的中断处理函数再调用abort() (在头

文件<cstdlib>中).

所以流程就是: terminate()---->默认的中断处理程序--------->abort()

这个处理是强制执行,同时因为abort会立即中断,和exit()不同的是,它不会为静态建立的对象调用析构函数(更不用动态的了),这明显是一个不妥的处理.

要改善上面的"强硬"中断,我们须要人为的干预,用我们自己"退出函数"来代替上面的"默认的中断处理函数",这样就不会去调用abort()即:

terminate()------>我们的退出函数

这样就避免了abor()的出现.

如何实现?

标准库函数set_terminate(参数),它接收terminate_handler类型的参数,返回该类型的值.(在头文件<exception>中)

这个类型在exception标准头文件中定义是: typedef void(*terminate_handler)();

注意这个terminate_handler是一个函数指针,没有参数也没返回值,因此,我们定义这个"替代"的"退出函数"也应是这样情况.如:

void myHandler(){

//自己的处理代码

}

看下面的,抛出int型,但捕捉的是double,因此捕捉漏了..进入默认的处理环节,但由于我们定义了自己的"退出函数",于是进入我们预定义的函数处理

#include <iostream>
#include<exception>
using namespace std;
void fun(){
	cout<<"yes"<<endl;
	exit(-1);
} 
int main(int argc, char *argv[]){
	int i=3;
	terminate_handler p=set_terminate(fun);
	try{
		throw i;
	}
	catch(double& e){
		cout<<"OK"<<endl;
	}
	return 0;
}

运行结果：

yes

请按任意键继续. . .

上面的返回值p是一个指针，它指向所设置的旧处理程序（这样存储起来以便在后面需要时恢复它），这里的旧处理程序就是原来的＂默认的中断处理函数＂，

　　　我们只要在这个语句后面再加一个set_terminate(p); 这样就恢复了原来的处理函数,即调用默认的中断处理函数,它会去调用abort(),所以这时结果就是:

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
请按任意键继续. . .

注意:第一次调用set_terminate(),返回值是指向默认的处理程序的指针.

以后每次再调用都会建立一个新的处理程序,并返回实际起作用的处理程序的指针.

#include <iostream>
#include<exception>
using namespace std;
void fun(){
	cout<<"yes"<<endl;
	exit(-1);
} 
void fun1(){
	cout<<"yes1111"<<endl;
	exit(-1);
}
void fun2(){
	cout<<"yes2222"<<endl;
	exit(-1); 
}
int main(int argc, char *argv[]){
	int i=3;
	terminate_handler p=set_terminate(fun);
	p=set_terminate(fun1);
	p=set_terminate(fun2);//此时只有这个起作用 
//    set_terminate(p);
	try{
		throw i;
	}
	catch(double& e){
		cout<<"OK"<<endl;
	}
	return 0;
}

结果是:

yes2222
请按任意键继续. . .

分析:先是用fun去替换了默认的中断处理程序,然后再用fun1()去代替了fun()处理程序,最后用fun2()替换了fun1()处理程序.

因此最后的替换程序是fun2(),所以输出的是yes2222,,注意这里的 p是指向的最近的"被替换的"的fun1()

如果我们去掉注释句,执行set_terminate(p),实际上就是让fun1()去替换.因此此时结果为:

yes1111
请按任意键继续. . .

所以上面的"恢复"原来的处理函数,就是上面的意思.

从上面可以看到,这实际上就有点类似windows编程中的hook技术.

7. try捕捉的强大性

try中出现的异常,哪怕是其中的函数的异常,还是函数中再调用函数的异常,都会被try捕捉.

另外,可以进行预判,如下面,虽然是同样的函数捕捉异常,但在catch块中可以不一样,因为如果可以人为事先料定在哪种情况出问题,就可以

连续写出这样的语句

try{
    ...
	fun();//这块可以预判某处异常 
	...
}
catch(...){
    ...
}
...
try{
   ...
   fun();//这块可以预判另一处异常 
   ... 
}
catch(...){
    ...
}

8. 嵌套的try块

原则:外层的try的异常不能被内层捕捉,但是,内层中的异常如果漏了会被外层捕捉.

try{//外层 
	...
	try{//内层 
		...
	}
	catch(...){//内层,捕获内层异常 
		...
	}
	...
} 
catch(...){//外层,捕获外层异常和内层没捕获到的异常 
	...
}

9. 用类对象作为异常

前提: 定义的异常类的成员函数不能抛出异常.

抛出异常对象的顺序:

先复制异常对象(创建一个临时对象),再释放原对象,因为退出try,该对象就超出了作用域(就要析构)

之后,把对象副本传递给catch处理程序,如果参数是一个引用,就按引用传递.

10. 匹配的处理.

try中抛出的异常类型要与catch中的异常类型匹配,如果一个都没匹配到,就会调用默认的中断处理程序.

如果是基本类型,就要求参数与异常类型完全匹配;

如果是类对象的异常,就会进行自动类型转换,以便匹配处理程序中的参数.

匹配的情况如下:

一.参数类型与异常类型完全匹配,忽略const;

二. 参数类型是异常类类型的直接或间接基类,或是异常类的直接或间接基类的引用. 忽略const;

三.异常与参数都是指针,异常类型可以自动转换为参数类型,忽略const

因此,如果基类参数排前派生类型之前,则总是选择基类参数的处理程序来处理派生的,即:派生类型的处理程序永远不会执行.

11、virtual对动态类型的保留。

原则：一般catch中采用的是参数的引用，一是可以避免拷贝构造，二是加快速度。

当类层次中有virtual时，引用将保留原基类或派生类的动态特性，即：其原类类型不变。如果是按值传送，就不一样了，无论如何都是

要复制，最终的目的是基类，即对象切片现象。

检查一个变量用 typeid() 它返回是type_info类型，可以用typeid().name提取这个类型名。

它头文件<typeinfo>中。

12、重新抛出异常：相当于二传手。

形式： throw; //不跟参数，表明原异常将“原封不动”地再次向外抛出。

注意下面的区别：

#include <iostream>
using namespace std;
class A{
	const char* p;
	public:
	A(const char* m="A"):p(m){}
	A(const A&){cout<<"copy"<<endl;}
	virtual const char* what()const{return p;}
};
class B:public A{
	public:
	B(const char* m="B"):A(m){}
};
int main(int argc, char *argv[]){
	A a; B b;
	try{
	    try{
	        throw b;
	    }
	    catch(A& e){
	        throw;//throw e;
	        cout<<"内层"<<endl;
	    }
	}
	catch(A& e){
	    cout<<"外层"<<endl;
	}
	return 0;
}

结果:

copy
外层
请按任意键继续. . .

如果把throw换成throw e;则结果为:
copy

copy
外层
请按任意键继续. . .

这是什么原因呢?

首先抛出throw b;将产生一个临时变量用拷贝构造,b本身析构.这是第一个copy产生的原因.

接着就有区别了:

如果是throw; 则相当于是二传手,因为是引用,直接把这个临时再次抛出(因此不存在着复制问题)

如果是throw e;就不一样了,,它会把再次造就一个临时变量(拷贝构造,第二个copy产生),原来的第一个临时变量因离开本作用区而析构.

第二个临时变量将进入外层中捕捉.

13、捕获所有异常：catch-all

当我们不能明确知道会抛出什么异常时，可以用“捕获所有异常”来进行拦截。

定义： catch(...) //注意，参数用三个点，表示该块处理所有异常。

catch(...){

//code to handle any exception....

}

它适用于我们对异常一无所知，为了防止漏捕，可以这个“终极”大法进行捕捉。

14、抛出异常的函数。

当调用函数语句位于try块时，可以捕获所有函数产生的异常。

但这样有缺点：它会立即中断函数，造成一些损失。

为了弥补这个bug，可以在函数中（函数体内）或函数体中（整个函数体）进行捕捉相关异常。注意这与调用函数的代码是有区别的。

定义：只须在函数体左花括号中加上关键字try，再在右花括号后加上catch处理语句。

void fun(int arg)//void fun(int arg) throw(A) 
try{
    //函数代码 
}
catch(A& a){
    //异常a处理 
}
catch(B& b){
	//异常b处理  
}

这样就可以处理比较方便。

一、限制函数可能抛出的异常。

有时为了使得一些异常在函数体中进行处理，而另一些则通过函数外层处理，这时就需要把相关异常抛到处层去。

定义：在函数头的后面指明可以抛到外层去的异常（见上面函数头后面注释句）

（1）函数头后有 throw(A,B)等，说明有限制，设置了一个哨卡，只有A、B类具有通信证可以抛出到外层。

（2）函数头后有throw(), 说明函数有限制，设置了一个哨卡，但没有一个类型可以抛出外层去，即禁止抛出到外层。

（3）函数后没有什么，说明函数没有限制，连哨卡都没有，只要在函数体中漏出的异常都可以抛出到外层去。

注意：如果函数有异常说明，就必须在函数声明和函数的定义中列出它。

void fun(int arg) throw(A,B);//声明

.....

void fun(int arg) throw(A,B){ ...} //定义

但是在用typedef定义函数指针的类型时，不能包含限制异常说明，因为它不是类型的一部分。

typedef void (*fun)(int); //没有限制说明

fun pfun throw(A,B);

#include <iostream>
using namespace std;
void fun() throw(int,double)//限制函数体内不能捕获int,double,只有用外层调用函数的try来捕获
try{
	int i=1;
	double j=3.2;
	char k='e';
	throw i;
}
catch(char& e){
	cout<<"char"<<endl;
}
int main(int argc, char *argv[]){
	fun();
	return 0;
}

结果：
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
请按任意键继续. . .

------------------------------------

当改为throw k时：结果如下：

char
请按任意键继续. . .

二、未预料到的异常

根据一，我们限制了相关能抛出到外层的异常，但这又引起一个问题。

如果函数体中的有4种异常，函数体能捕捉到1种，能抛出到外层的异常有2种，那么就有一种没法捕获。

这就是未预料的异常。这时会发生什么呢?

标准函数unexpected()----->默认处理函数------>terminate()---->默认中断处理函数----->abort()

如上流程：首先它会调用标准库函数unexpected(),这会使程序暂停，同时,unexpected()调用一个处理函数，这个处理函数的默认操作

就是调用terminate(),terminate()再调用默认的中断处理函数，这个中断处理函数再调用abort()进行强行中断程序。

为了避免它调用默认的unexpected()函数（引发后面的强行中断），可以用一个类似替换terminate()一样的函数来处理。

做法：把我们自己的处理函数地址作为参数，调用set_unexpected()函数，这样，就把控制转接到我们自己的函数来。

set_unexpected()的参数类型是：typedef void (*unexpected_handler)( );

因此，同样我们自己的处理函数是不带参数，也没有返回值的。

对于我们定义的处理函数，必须有三种结束方式：

（1）抛出一个异常，该异常遵循抛出未预料到异常的异常声明。（也就是再次发生这样的异常）

（2）抛出bad_exception类型异常，即标准<exception>中的标准异常类型。

（3）调用terminate()、exit()、abort(),,进行结束。

std::bad_exception类型的作用：可以为这种类型异常提供一个处理程序，我的处理程序不行，也许别人还要用到，这样为下一个处理程序

打好基础。

注意: 这个类型与不可预料的类型不一样，bad_exception一旦没有替代的处理程序，它一定是调用terminate()，而不可预料的类型调用的则

是unexpected().

15、构造函数中的异常：

构造时发生异常，将立即中断程序，不会调用析构函数，特别是那些new的内存是不会释放的.

发生构造时异常很多，比如new不成功（bad_alloc异常），初始化值不满足要求等等。

Example::Example(int count) throw(bad_alloc)
try:BassClass(count){
	//code
} 
catch(...){
	//code
}

同函数异常一样定义，但它可以包含初始化列表（如上面，构造基类），这样连基类也捕捉了。

16、析构函数中的异常。

一般的原则是：析构函数是不应该抛出异常的。

为什么呢?因为析构函数一般在抛出异常时提前已经执行了。当我们跳出析构时，会脱离析构函数作用域，这样会再次去调用析构，

就会出错，严重的情况是一直不断地调用析构，这是一个无止的循环。

但是：有时的确析构函数中有异常，怎么办呢?

应把try....catch...全部放在析构函数中。

重要：uncaught_exception()函数，返回值1或0

即当抛出异常，去执行catch块（哪怕没有代码），则返回0，否则是1.

简单地说，没有处理异常为1，处理异常为0

这样就可以判断是否处理了这个异常。

#include<exception> 
#include<iostream> 
#include<string> 
class Test{ 
	public: 
	Test(std::string msg):m_msg(msg){ 
		std::cout<<"In   Test::Test(\" "<<m_msg<<"\") "<<std::endl; 
	} 
	~Test(){ 
		std::cout<<"In   Test::~Test(\" "<<m_msg<<"\") "<<std::endl 
				<<"     std::uncaught_exception(   )   =   " 
				<<std::uncaught_exception() 
				<<std::endl; 
	} 
	private: 
	std::string   m_msg; 
}; 
int  main(){ 
	Test t1("outside   try   block "); 
	try{ 
		Test   t2("inside   try   block "); 
		throw   1; 
	} 
	catch(int i){ 
	} 
}

In Test::Test(" outside try block ")
In Test::Test(" inside try block ")
In Test::~Test(" inside try block ")
std::uncaught_exception( ) = 1
In Test::~Test(" outside try block ")
std::uncaught_exception( ) = 0
请按任意键继续. . .

上面t2,因throw 1中断，自动释放try块，因没有在catch中，所以，为1

当进入catch块，说明被捕捉到了,uncaught_exception()就会置0，当它析构时就会调用显示。