c++学习笔记(18.异常处理)

最新推荐文章于 2024-07-31 20:26:09 发布

qq418674358

最新推荐文章于 2024-07-31 20:26:09 发布

阅读量1.7k

点赞数 1

分类专栏： C++初探文章标签：异常处理 c++ 多态类

本文链接：https://blog.csdn.net/mbh_1991/article/details/18994621

版权

初学C++ 同时被 2 个专栏收录

19 篇文章 0 订阅

订阅专栏

C++初探

19 篇文章 4 订阅

订阅专栏

本节知识点：

1.异常与c语言的异常处理：

a. 异常就是代码中的一些特殊情况，如除法运算中除数为零的情况，还有就是一些函数中出现不符合要求的函数参数的情况，都属于异常情况！

b. 在c语言中对异常的处理通常有三种方式：

第一种，最常用的就是条件判断

第二种，goto语句

第三种，longjmp()函数和setjmp()函数

条件判断的示例代码：

#include <cstdlib>
#include <iostream>

using namespace std;

int MemSet(void* dest, unsigned int length, unsigned char v)
{
    if( dest == NULL )
    {
        return -1;
    }
    
    if( length < 4 )
    {
        return -2;
    }
    
    if( (v < 0) || (v > 9) )
    {
        return -3;
    }
    
    unsigned char* p = (unsigned char*)dest;
    
    for(int i=0; i<length; i++)
    {
        p[i] = v;
    }
    
    return 0;
}

int main(int argc, char *argv[])
{
    int ai[5];
    double ad[4];
    char ac[3];
    int ret;
    
    ret = MemSet(ai, sizeof(ai), 0);
    
    if( ret == 0 )
    {
    }
    else if( ret == -1 )
    {
    }
    else if( ret == -2 )
    {
    }
    else if( ret == -3 )
    {
    }
    
    ret = MemSet(ad, sizeof(ad), 1);
    
    if( ret == 0 )
    {
    }
    else if( ret == -1 )
    {
    }
    else if( ret == -2 )
    {
    }
    else if( ret == -3 )
    {
    }
    
    ret = MemSet(ac, sizeof(ac), 2);
    
    if( ret == 0 )
    {
    }
    else if( ret == -1 )
    {
    }
    else if( ret == -2 )
    {
    }
    else if( ret == -3 )
    {
    }
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

c. 可见条件判断的方法，使得正常逻辑的代码和异常处理的代码混合在一起，导致代码迅速膨胀，难以维护！而goto语句和setjmp()、longjmp()函数则可以将异常处理代码放在统一的地方，与正常逻辑代码分开。

2.c++中的异常处理：

a. c++中有着自己的一套异常处理方式，没有使用goto语句和setjmp()、longjmp()函数，是因为它们的安全性实在是很低！

b. c++中异常处理的语法

try语句块处理正常逻辑

catch语句块处理异常逻辑

throw语句引发一个异常

示例代码：

#include <iostream>
#define div_zero_error 1

using namespace std;

double div(double a, double b)
{
	if((-0.0000001<b)&&(b<0.0000001))
	{
		throw div_zero_error;
	}
	return a/b;
}

int main()
{	
	char a = 'c'; //try语句块外面依然可以放其他语句 
	try
	{ 
		cout << div(2,3) << endl;
		throw a; //throw后面可以直接 放数据 也可以放变量 
		//throw 'd';
		cout << div(1,0) << endl;
		cout << div(5,2) << endl;
	}
	catch(int a)
	{
		cout << "div_zero_error" << endl;	
	}
	catch(char) //catch语句后面，可以只有变量类型，没有具体变量 
	{
		cout << "test_error" << endl;
	}
	return 0;
}

注意：第一，并不是所有语句都要全部放在try或者catch语句块里面，可以放在try或者catch语句外面！

第二，throw语句后面，可以直接放数据，也可以放变量

第三，一个try语句后面可以有多个catch语句块，catch语句后面，可以只有变量类型，没有具体变量！
c. 当throw语句抛出一个异常的时候，首先在当前函数中看，throw语句是否在一个try语句块中，如果是则去判断这个try语句块对应的catch语句块中是否能够处理这个异常类型，如果不能处理或者throw语句不在一个try语句块中，则退出当前函数，返回到调用函数的位置看，看调用函数的语句是否在一个try语句块中，对应的catch是否能处理这个异常，不断重复返回到上层函数，直到遇到可以处理这个异常的catch语句。或者返回到了所有函数后，都无法处理抛出的这个异常，则程序异常终止！！！切记，即使异常在对应的catch语句块中完成了异常处理，程序也不能回到异常发生处或上层函数调用处继续执行了，程序只能接着处理异常的catch语句块后面继续执行！！！

如图：

d. c++的这种异常处理方式与常规的条件判断比较，优势在于异常代码块与正常代码块是分开的，便于代码管理，同时也避免了大量的条件判断(因为每种异常都会有一个自己的返回值，当函数结束时，需要判断是那一种异常，所以就存在大量判断，而且是每次调用函数都要重新判断，不能代码复用，导致垃圾代码大量膨胀)，条件判断中多种异常的情况(即返回好几个值的情况)，可以使用多个catch语句块完成，catch类型多的时候尽量不要使用基本类型，使用自己创建的类类型！

c++的这种异常处理与goto语句(setjmp函数)的比较，try.....catch语句，比goto语句要安全的多，如果是用goto语句进行跳转，这个过程根本就不考虑函数的建栈和退栈过程，它仅仅就是跳转过去执行而已！而throw语句，则不是！throw抛出异常的时候，是会退栈然后返回上层函数的，这一点要比goto安全多了！起码函数是正常结束的！而且，throw是一层一层的去寻找catch语句，在逻辑性上，也要比goto语句清晰很多！

try.....catch语句的示例代码：

#include <cstdlib>
#include <iostream>

using namespace std;

void MemSet(void* dest, unsigned int length, unsigned char v)
{
    if( dest == NULL )
    {
        throw -1;
    }
    
    if( length < 4 )
    {
        throw -2;
    }
    
    if( (v < 0) || (v > 9) )
    {
        throw -3;
    }
    
    unsigned char* p = (unsigned char*)dest;
    
    for(int i=0; i<length; i++)
    {
        p[i] = v;
    }
}

int main(int argc, char *argv[])
{
    int ai[5];
    double ad[4];
    char ac[3];
    
    try
    {
        MemSet(ai, sizeof(ai), 0);
        MemSet(ad, sizeof(ad), 1);
        MemSet(ac, sizeof(ac), 2);
    }
    catch(int e)
    {
        cout<<e<<endl;
    }
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

注意：上面代码是c++异常处理的常规用法！

比对代码：

#include <cstdlib>
#include <iostream>

using namespace std;

int MemSet(void* dest, unsigned int length, unsigned char v)
{
	int ret = 0;
    if( dest == NULL )
    {
        return  -1;
    }
    
    if( length < 4 )
    {
        return  -2;
    }
    
    if( (v < 0) || (v > 9) )
    {
        return  -3;
    }
    
    unsigned char* p = (unsigned char*)dest;
    
    for(int i=0; i<length; i++)
    {
        p[i] = v;
    }
    return 0;
}

int main(int argc, char *argv[])
{
    int ai[5];
    double ad[4];
    char ac[3];
    
    if(0==MemSet(ai, sizeof(ai), 0))
    {}
    else
    {
		if(-1==MemSet(ai, sizeof(ai), 0))
		{
			cout << -1 << endl;
		}
		else if(-2==MemSet(ai, sizeof(ai), 0))
		{
			cout << -2 << endl;
		}
		else if(-3==MemSet(ai, sizeof(ai), 0))
		{
			cout << -3 << endl;
		}
	}
	if(0==MemSet(ad, sizeof(ad), 1))
	{}
    else
    {
		if(-1==MemSet(ad, sizeof(ad), 1))
		{
			cout << -1 << endl;
		}
		else if(-2==MemSet(ad, sizeof(ad), 1))
		{
			cout << -2 << endl;
		}
		else if(-3==MemSet(ad, sizeof(ad), 1))
		{
			cout << -3 << endl;
		}
	}
	if(0==MemSet(ac, sizeof(ac), 2))
	{}
    else
    {
		if(-1==MemSet(ac, sizeof(ac), 2))
		{
			cout << -1 << endl;
		}
		else if(-2==MemSet(ac, sizeof(ac), 2))
		{
			cout << -2 << endl;
		}
		else if(-3==MemSet(ac, sizeof(ac), 2))
		{
			cout << -3 << endl;
		}
	}
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

注意：上面就是使用条件判断的异常处理方式，可见代码膨胀的样子！但是使用条件判断可以保证每一个正常逻辑的代码都得到执行，而try.....catch语句就保证不了！因为当发生throw异常的时候，代码就会跳转到catch语句块中，然后从catch语句块往后执行了！会丢失throw语句后面部分的正常逻辑代码！
e. 同一个try语句块可以跟上多个catch语句块，同一个try语句块可以抛出多种不同类型的异常，不同类型的异常由不同的catch语句块负责处理！异常被抛出后会自上而下逐一匹配catch语句块，异常匹配时，不会进行默认类型转换！

示例代码：

#include <cstdlib>
#include <iostream>

using namespace std;

int test(int i)
{
    if( i == 1 )
    {
        throw -1;
    }
    
    if( i == 2 )
    {
        throw "ERROR";
    }
    
    if( i == 3 )
    {
        throw 0.5;
    }
    
    if( i == 4 )
    {
        throw 'd';
    }
    
    return i;
}

int main(int argc, char *argv[])
{
    for(int i=0; i<4; i++)
    {
        try
        {
            cout<<test(i)<<endl;
        }
        catch(int e)
        {
            cout<<"Int: "<<e<<endl;
        }
        catch(const char* e)
        {
            cout<<"const char*: "<<e<<endl;
        }
        catch(double e)
        {
            cout<<"double: "<<e<<endl;
        }
    }
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

注意：第一，catch后面可以只有类型，没有具体变量，但是当没有变量的时候，catch语句块中就不能获得throw语句抛出的异常参数了！

第二，对于这样一个try语句块和多个catch语句块的时候，基本数据类型往往是不够用的，所以尽量使用自己通过class关键字定义的类类型！

3.深入异常处理：

a.c++中的catch语句可以使用...捕获所有类型的异常。catch(...)虽然可以捕获所有类型的异常但却无法得到异常信息。 catch(...)一般作为最后一个异常处理块出现。看见代码中的catch就要意识到这里在处理异常情况，而异常是在对应的try中产生的。

b.在catch语句块中，仍然可以使用throw抛出异常

c. 在catch语句块中，可以使用throw a ，也可以只使用throw; 当throw后面没有变量也没有数据的时候，是表示要抛出catch语句块接受的异常类型(即在catch(int a)这个语句块中，throw; 就是throw a; 的简写)。所以throw; 这种情况只能在catch语句块中使用，不能在try语句块中使用。同时即使是catch(int)这样的语句块中，使用throw; 在外层的catch(int e)异常处理中，也可以获得e的值，就是最初的那个throw 抛出的值！应该是编译器自动提供了一个中间变量！

d. 注意在，catch(...)中的throw; 可以直接把接收到的异常再次抛出！应该也是编译器自动提供了中间变量！

示例代码：

#include <cstdlib>
#include <iostream>

using namespace std;

int test(int i)
{
    if( i == 1 )
    {
        throw -1;
    }
    
    if( i == 2 )
    {
        throw "ERROR";
    }
    
    if( i == 3 )
    {
        throw 0.5;
    }
    
    if( i == 4 )
    {
        throw 'd';
    }
    
    return i;
}

int main(int argc, char *argv[])
{
    for(int i=0; i<5; i++)
    {
       	try
	    {
			try
        	{
          	  cout<<test(i)<<endl;
        	}
       		catch(int)
        	{
            //	cout<<"Int: "<<e<<endl;
            	throw;
        	}
        	catch(const char* e)
        	{
            	cout<<"const char*: "<<e<<endl;
            	throw 3;
        	}
        	catch(double e)
        	{
            	cout<<"double: "<<e<<endl;
            	throw;
        	}
        	catch(...)
			{
				cout << "catch(...) " << endl;
				throw;
			} 
		}
		catch(double a)
		{
			cout << "throw catch(double) " << endl;
		}
		catch(int a)
		{
			cout << "throw catch(int) " << endl;
			cout << a << endl;
		}
		catch(char a)
		{
			cout << "throw catch(char) " << endl;
		}
		catch(...)
		{
			cout << "throw catch(...) " << endl;
		}
		
    }
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

4.异常与对象：

a. 切记，千万不要在构造函数中抛出异常，构造函数中可能会申请系统资源(如new int[5])，而在构造函数中抛出异常则会导致对象构造不完全，对于不完全对象的析构函数是不会被调用的，因此可能会造成资源泄漏！(即析构函数不被调用，析构函数中的delet [] 没有执行，造成内存泄漏)

示例代码：

#include <iostream> 

using namespace std;

class test
{
public:
	test()
	{
		cout << "test()....." << endl;
		throw 'a';
	}
	~test()
	{
		cout << "~test()....." << endl;
	}
};
void fun()
{
	try
	{
		test t1;
	}
	catch(char e)
	{
		cout << e << endl;
	}
}

int main()
{
	fun();
	return 0;
}

注意：上面的对象因为是构造不完全的对象，所以对象的析构函数不被调用！

5.工程中的异常应用：

a. 在工程中会定义一系列的异常类，通过继承可以得到一个异常类族。每个类代表工程中可能出现的一种异常类型！

b. 在工程中可以使用标准库中的异常类，可以将标准库中的异常类作为基类派生新的异常类！

c. 标准库中的异常都是从exception类派生而来的，exception类有两个主要分支，logic_error用于描述程序中出现的逻辑错误，如：传递无效参数。runtime_error用于描述无法预料的事件所造成的错误，如：内存耗尽、硬件错误等。

标准库中的异常如图：

d.标准库中的异常族包含在<stdexcept>头文件中！

e. logic_error和runtime_error都提供了一个参数为字符串的构造函数，这样就能够保存异常信息，还可以通过what()成员函数得到异常信息！！！

示例代码：

#include <iostream>
#include <stdexcept> //异常族的头文件 

using namespace std;

double Div(double a, double b)
{
	//invalid_argument p("Divide by zero...");
   if( (-0.00000001 < b) && ( b < 0.00000001) )
   {
		/*
		invalid_argument是一个异常类，invalid_argument("Divide by zero...")
        是直接调用这个类的构造函数(后面是构造函数的参数，也是异常信息)，
		此时编译器产生一个临时对象，throw就是抛出了这个临时对象 
		*/
		throw invalid_argument("Divide by zero..."); 
		//throw p;
   }
    
   return  a / b;
}

int main()
{
	try
	{
		cout<<Div(1, 0)<<endl;
	}
	//这里使用引用是为了避免由于对象构造与拷贝的开销，使用引用就不会再重新创建一个对象进行拷贝了 
	catch(invalid_argument& error)
	{
		cout << error.what() << endl;//通过what成员函数获得异常信息 
	}
	return 0;
}

注意：在catch语句后，可以使用引用参数，使用引用就避免了对象的构造和拷贝的开销，效率会高些！
使用自己创建的异常对象示例代码：

#include <iostream>
#include <stdexcept> //异常族的头文件 

using namespace std;

class div_zero_error : public logic_error
{
public:
	div_zero_error(const char* s) : logic_error(s)//初始化列表~~~ 
	{
		
	} 
};

double Div(double a, double b)
{
	//div_zero_error p("Divide by zero...");
   if( (-0.00000001 < b) && ( b < 0.00000001) )
   {
		/*
		div_zero_error是一个异常类，div_zero_error("Divide by zero...")
        是直接调用这个类的构造函数(后面是构造函数的参数，也是异常信息)，
		此时编译器产生一个临时对象，throw就是抛出了这个临时对象 
		*/
		throw div_zero_error("Divide by zero..."); 
		//throw p;
    }
    
    return  a / b;
}

int main()
{
	try
	{
		cout<<Div(1, 0)<<endl;
	}
	//这里使用引用是为了避免由于对象构造与拷贝的开销，使用引用就不会再重新创建一个对象进行拷贝了 
	catch(exception& error) //使用exception类型 是为了接受各种类型的异常 
	{
		cout << error.what() << endl;//通过what成员函数获得异常信息 
	}
	return 0;
}

注意：第一，当希望通过标准库中的异常类族派生出自己的异常类的时候，首先要自己定义类并继承基类，这样自己的异常类中就继承了logic_error类的构造函数，这个带参的构造函数(即参数是字符串，用来保存异常信息的)是对应what()成员函数的。所以就出现了这样的语句，div_zero_error(const char* s) : logic_error(s) 这条语句很有意思，这条语句使用了构造函数的初始化参数列表！当创建div_zero_error类对象的时候，先接收构造函数的参数，且保存在s中，不管是从初始化列表的角度看，还是从父类构造函数的角度看，都是先调用logic_error类的构造函数，再调用div_zero_error类的构造函数，此时在调用logic_error类的构造函数的时候，就完成了对异常信息的保存！！！等于说把子类div_zero_error的构造函数的参数赋值给了父类logic_error的构造函数的参数，用于传递异常信息，即div_zero_error的构造函数的参数就是用来接收异常信息的！对于那些标准库中的其他子类，原理依然相同！

第二，在throw语句中，throw后面的对象，不管是临时对象，还是事先创建好的对象，这个对象在创建的时候一定是带字符串参数的，如：div_zero_error p("Divide by zero...");和div_zero_error("Divide by zero..."); 没有参数是编译不过的(这个参数就是异常信息)，因为在创建异常类对象的时候，是需要调用父类logic_error的带字符串参数的构造函数的，所以会报错！当然对于属于标准库中的异常类，依然需要准守这个规则！因为标准库中的异常类的创建过程，跟自己定义的异常类创建的过程是一模一样的！！！只不过一个是库函数帮你写好的，一个是你自己写的，代码是相同的！

第三，对于工程中的代码，如果已经约定好所有的异常都是基于exception这个基类派生的异常类族，当想接收所有异常的时候，就不用catch(...)这样的语句了，因为catch(...)不能获得what函数的异常信息！可以使用catch(exception& error)这样的语句来捕获所有异常，这里利用的是子类父类之间的赋值兼容性原则(即子类是特殊的父类，exception类可以接收所有他的子类)！

6.函数级try语法：

注意：其实两段代码没有任何区别，仅仅是多一对括号和少一对括号的区别！右侧的代码主要是，怕try语句块中的代码过多，使程序员忘记这是在try语句块中！仅仅是为了提高代码的可读性和维护性！意义并不是很大，遇到了能够认识就可以了！这里有一个问题是要注意的，这种等效关系的前提是，函数的所有正常逻辑的语句全部在try代码块中！！！也就是说函数体除了try代码块，和catch代码块外没有别的语句！