三十四、异常（一）异常抛出、异常捕获、异常传播

一、程序错误

程序错误包含以下：

编译错误，即语法错误。程序就无法被生成运行代码。

运行时错误

• 不可预料的逻辑错误
• 可以预料的运行异常 

例如：

动态分配空间时可能不会成功

打开文件可能会失败

除法运算时分母可能为0

整数相乘可能溢出

数组越界……

二、C语言处理程序错误的方法

(1)、返回值

double func()
{
	int ret = func();
	if (ret == -1)
	{
	}
	else if(ret == -2)
	{
	}
	else if (ret == -3)
	{
	}
}

(2)、errno

  在linux系统调用和C函数中，函数调用出错会设置全局变量error的值，我们需要在程序中检查error是否等于-1，等于-1的话就要进行错误处理。

(3)、goto语句

局部跳转。示例：

int test()
{
	char*p1 = (char*)malloc(3);
	if (p1!=NULL)
	{
	}
	else
	{
		goto POS1;
	}
	char*p2 = (char*)malloc(3);
	if (p2!=NULL)
	{
	}
	else
	{
		goto POS1;
	}
POS1:
	exit(1);
POS2:
	free(p1);
	exit(1);
}

(4)、setjmp、longjmp

长跳转。示例：

#include <stdio.h>
#include <setjmp.h>
jmp_buf buf;
double Divide(double a, double b)
{
	if (b == 0.0)
	{
		longjmp(buf, 1);// 跳转到保存点，即保存的栈信息处设置返回值
	}
	else
		return a / b;
}

int main(void)
{
	int ret;
	ret = setjmp(buf);//讲当前栈信息保存在buf中，保存成功返回0
	if (ret == 0)			// try
	{
		printf("division ...\n");
		printf("%f\n", Divide(5.0, 0.0));
	}
	else if (ret == 1)		// catch
	{
		printf("divisiong by zero\n");
	}
	return 0;
}

C语言的出错处理被认为是紧耦合的，函数的使用者必须在非常靠近函数调用的地方编写错误处理代码，这会使得其变得笨拙以及难以使用。

三、异常语法

try
{
   	//try语句块
}
catch（类型1  参数1）
{
   	//针对类型1的异常处理
}
catch （类型2  参数2）
{
   	//针对类型2的异常处理
}
…
catch （类型n  参数n）
{
   	//针对类型n的异常处理
}

四、异常抛出

• 可以抛出内置类型异常也可以抛出自定义类型异常
• throw抛出一个类对象会调用拷贝构造函数

五、异常捕获

• 一个异常处理器一般只捕捉一种类型的异常
• 异常处理器的参数类型和抛出异常的类型相同
• …表示可以捕获任何异常

示例：

#include <iostream>
#include <string>
using namespace std;
//自定义类型异常
class MyException
{
public:
	MyException(const char* message)
		: message_(message)
	{
		cout<<"MyException ..."<<endl;
	}
	MyException(const MyException& other) : message_(other.message_)
	{
		cout<<"Copy MyException ..."<<endl;
	}
	~MyException()
	{
		cout<<"~MyException"<<endl;
	}

	const char* what() const
	{
		return message_.c_str();
	}
private:
	string message_;
};
double Divide(double a, double b)
{
	if (b == 0.0)
	{
		//MyException e("division by zero");//调用拷贝构造函数
		//throw e;
		throw MyException("division by zero");//和函数返回对象类似，不调用拷贝构造函数
		//throw 1;
	}
	else
		return a / b;
}
int main(void)
{
	try
	{
		cout<<Divide(5.0, 0.0)<<endl;
	}
	catch (MyException& e)
	{
		cout<<e.what()<<endl;
	}
	//catch (int)
	//{
	//	cout<<"int exception ..."<<endl;
	//}
	catch (double)
	{
		cout<<"double exception ..."<<endl;
	}
	catch (...)
	{
		cout<<"catch a exception ..."<<endl;
	}
}

六、异常传播

try块可以嵌套，程序按顺序寻找匹配的异常处理器，抛出的异常将被第一个类型符合的异常处理器捕获。如果内层try块后面没找到合适的异常处理器，该异常向外传播，到外层try块后面的catch块中寻找没有被捕获的异常将调用terminate函数，terminate函数默认调用abort终止程序。可以使用set_terminate函数指定terminate函数将调用的函数。

示例：

#include <iostream>

using namespace std;

class MyException
{
public:
	MyException(const char* message)
		: message_(message)
	{
		cout<<"MyException ..."<<endl;
	}
	MyException(const MyException& other) : message_(other.message_)
	{
		cout<<"Copy MyException ..."<<endl;
	}
	~MyException()
	{
		cout<<"~MyException"<<endl;
	}

	const char* what() const
	{
		return message_.c_str();
	}
private:
	string message_;
};

void MyTerminate()
{
	cout<<"MyTerminate ..."<<endl;
}

int main(void)
{
	set_terminate(MyTerminate);
	try
	{
		try
		{
			throw MyException("test exception");
		}
		catch (int)
		{
			cout<<"Inner ..."<<endl;
			cout<<"catch a int exception"<<endl;
		}
		//catch (MyException& e)
		//{
		//	cout<<"Inner ..."<<endl;
		//	cout<<e.what()<<endl;
		//	throw e;
		//}
	}
	catch (int)
	{
		cout<<"Outer ..."<<endl;
		cout<<"catch a int exception"<<endl;
	}
	catch (MyException& e)
	{
		cout<<"Outer ..."<<endl;
		cout<<e.what()<<endl;
	}
}

七、栈展开

沿着嵌套调用链接向上查找，直至为异常找到一个catch子句。这个过程称之为栈展开。

• 栈展开时局部对象调用析构函数

注意：

析构函数应该从不抛出异常

栈展开期间会执行析构函数，在执行析构函数的时候，已经引发的异常但还没处理，如果这个过程中析构函数又抛出新的异常，将会调用标准库的terminate函数。

• 异常与构造函数

构造函数中可以抛出异常。如果在构造函数函数中抛出异常，则可能该对象只是部分被构造。即使对象只是被部分构造，也要保证销毁已构造的成员。

示例：

#include <iostream>
#include <string>
using namespace std;

class MyException
{
public:
	MyException(const char* message)
		: message_(message)
	{
		cout<<"MyException ..."<<endl;
	}
	MyException(const MyException& other) : message_(other.message_)
	{
		cout<<"Copy MyException ..."<<endl;
	}
	~MyException()
	{
		cout<<"~MyException"<<endl;
	}

	const char* what() const
	{
		return message_.c_str();
	}
private:
	string message_;
};

class Test
{
public:
	Test()
	{
		cout<<"Test ..."<<endl;
	}
	Test(const Test& other)
	{
		cout<<"Copy Test ..."<<endl;
	}
	~Test()
	{
		cout<<"~Test ..."<<endl;
	}
};

class Obj
{
public:
	Obj()
	{
		cout<<"Obj ..."<<endl;
	}
	Obj(const Obj& other)
	{
		cout<<"Copy Obj ..."<<endl;
	}
	~Obj()
	{
		cout<<"~Obj ..."<<endl;
	}
};

class Test3
{
public:
	Test3()
	{
		cout<<"Test3 ..."<<endl;
	}
	Test3(const Test3& other)
	{
		cout<<"Copy Test3 ..."<<endl;
	}
	~Test3()
	{
		cout<<"~Test3 ..."<<endl;
		//throw 4;//在析构函数里抛出异常，会调用<span style="font-size: 14px;">terminate终止程序</span>
	}
};

class Test2
{
public:
	Test2()
	{
		obj_ = new Obj;
		cout<<"Test2 ..."<<endl;
		throw MyException("test exception2");
	}
	Test2(const Test2& other)
	{
		cout<<"Copy Test2 ..."<<endl;
	}
	~Test2()
	{
		delete obj_;
		cout<<"~Test2 ..."<<endl;
	}
private:
	Obj* obj_;
};

int main(void)
{
	try
	{
		Test3 t3;
		throw MyException("Test exception3");
	}
	catch (MyException& e)
	{
		cout<<e.what()<<endl;
	}
	catch (int)
	{
		cout<<"catch a int exception"<<endl;
	}
}

输出：