c++ - 异常

将问题检测和问题处理相分离；
在异常处理过程中，由问题检测代码可以抛出一个对象给问题处理代码，通过这个对象的类型和内容，实际上完成了两个部分的通信，通信的内容是“出现了什么错误”。当然，各种语言对异常的具体实现有着或多或少的区别，但是这个通信的思想是不变的。

异常

异常基本概念

在Win32中，获取异常可以使用GetLastError函数来获取上一个错误；
在C语言的世界中，对错误的处理总是围绕着两种方法：一是使用整型的返回值标识错误；二是使用errno宏（可以简单的理解为一个全局整型变量）去记录错误。当然C++中仍然是可以用这两种方法的。
这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回1表示成功，返回0表示出错；而有些函数返回0表示成功，返回非0表示出错。
还有一个缺点就是函数的返回值只有一个，你通过函数的返回值表示错误代码，那么函数就不能返回其他的值。当然，你也可以通过指针或者C++的引用来返回另外的值，但是这样可能会令你的程序略微晦涩难懂。

C++异常

• 函数的返回值可以忽略，但异常不可忽略。如果程序出现异常，但是没有被捕获，程序就会终止，这多少会促使程序员开发出来的程序更健壮一点。而如果使用C语言的error宏或者函数返回值，调用者都有可能忘记检查，从而没有对错误进行处理，结果造成程序莫名其面的终止或出现错误的结果。
• 整型返回值没有任何语义信息。而异常却包含语义信息，有时你从类名就能够体现出来。
• 整型返回值缺乏相关的上下文信息。异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息。
• 异常处理可以在调用跳级。这是一个代码编写时的问题：假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求你在每一级函数中都要进行处理。而使用异常处理的栈展开机制，只需要在一处进行处理就可以了，不需要每级函数都处理。

#include <iostream>
using namespace std;

int myDevide(int a, int b)
{
	if (b == 0)
	{
		//throw -1;
		throw 3.14;	//抛出一个double类型的异常
		//throw 'a';
	}
	return a / b;
}

void test()
{
	int a = 10;
	int b = 0;
	int ret;
	ret = myDevide(a, b);
	if (ret == -1)
	{
		//如果b定义为-2，那么则无法接受异常处理
	}
}

void test01()
{
	int a = 10;
	int b = 0;
	try
	{
		myDevide(a, b);
	}
	catch (int)
	{
		cout << "int 类型异常捕获" << endl;
	}
	catch (double)
	{
		cout << "double 类型异常捕获" << endl;
	}
	catch (...)
	{
		cout << "其他异常捕获" << endl;
	}
}

int main()
{
	try
	{
		test01();
	}

	catch (double)
	{
		cout << "main double 类型异常捕获" << endl;
	}
	return 0;
}

• 若有异常则通过throw操作创建一个异常对象并抛出。
• 将可能抛出异常的程序段放到try块之中。
• 如果在try段执行期间没有引起异常，那么跟在try后面的catch字句就不会执行。
• catch子句会根据出现的先后顺序被检查，匹配的catch语句捕获并处理异常(或继续抛出异常)
• 如果匹配的处理未找到，则运行函数terminate将自动被调用，其缺省功能调用abort终止程序。
• 处理不了的异常，可以在catch的最后一个分支，使用throw，向上抛。

c++异常处理使得异常的引发和异常的处理不必在一个函数中，这样底层的函数可以着重解决具体问题，而不必过多的考虑异常的处理。上层调用者可以在适当的位置设计对不同类型异常的处理。

自定义异常

#include <iostream>
using namespace std;
class myException
{
public:
	void printError()
	{
		cout << "自定义异常" << endl;
	}

private:

};

int myDevide(int a,int b)
{
	if (b == 0)
	{
		throw myException();			//匿名对象
	}
	return a / b;
}

void test()
{
	int a = 10;
	int b = 0;
	try
	{
		myDevide(a, b);
	}
	catch (int)
	{
		cout << "int error" << endl;
	}
	catch (double)
	{
		cout << "double error" << endl;
	}

	catch (myException e)
	{
		e.printError();
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	test();
	system("pause");
	return 0;
}

异常机制和函数机制互不干涉,但是捕捉方式是通过严格类型匹配。

栈解旋

异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上构造的所有对象，都会被自动析构。析构的顺序与构造的顺序相反，这一过程称为栈的解旋(unwinding).

#include <iostream>
using namespace std;

class myException
{
public:
	void printError()
	{
		cout << "自定义异常" << endl;
	}

private:

};

class Person
{
public:
	Person()
	{
		cout << "Person 构造函数" << endl;
	}
	~Person()
	{
		cout << "Person 析构函数" << endl;
	}
private:
	
};


int Mydevice(int a, int b)
{
	if (b == 0)
	{
		Person p1;
		Person p2;

		throw myException();

	}
	return a / b;
}

void test()
{
	int x = 10;
	int y = 0;
	try
	{
		Mydevice(x, y);
	}
	catch (myException e)
	{
		e.printError();
	}

}

int _tmain(int argc, _TCHAR* argv[])
{
	test();
	return 0;
}

异常接口声明

• 为了加强程序的可读性，可以在函数声明中列出可能抛出异常的所有类型，例如：void func() throw(A,B,C);这个函数func能够且只能抛出类型A,B,C及其子类型的异常。
• 如果在函数声明中没有包含异常接口声明，则此函数可以抛任何类型的异常，例如:void func()
• 一个不抛任何类型异常的函数可声明为:void func() throw()
• 如果一个函数抛出了它的异常接口声明所不允许抛出的异常,unexcepted函数会被调用，该函数默认行为调用terminate函数中断程序。

//可抛出所有类型异常
void TestFunction01(){
	throw 10;
}

//只能抛出int char char*类型异常
void TestFunction02() throw(int,char,char*){
	string exception = "error!";
	throw exception;
}

//不能抛出任何类型异常
void TestFunction03() throw(){
	throw 10;
}

int main(){

	try{
		//TestFunction01();
		//TestFunction02();
		//TestFunction03();
	}
	catch (...){
		cout << "捕获异常!" << endl;
	}
	
	system("pause");

异常变量生命周期

• throw的异常是有类型的，可以是数字、字符串、类对象。
• throw的异常是有类型的，catch需严格匹配异常类型。

#include <iostream>
using namespace std;

class MyException
{
public:
	MyException()
	{
		cout << "MyException默认构造" << endl;
	}

	MyException(const MyException & e)
	{
		cout << "MyException拷贝构造" << endl;
	}
	~MyException()
	{
		cout << "MyException默认析构" << endl;
	}
};

void doWork()
{
	throw new MyException();
}

void test()
{
	try
	{
		doWork();
	}
	catch (MyException *e)
	{
		cout << "捕获异常" << endl;

		delete e;
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	test();
	system("pause");
	return 0;
}

异常多态

#include <iostream>
using namespace std;


//异常基类
class BaseException{
public:
	virtual void printError(){};
};

//空指针异常
class NullPointerException : public BaseException{
public:
	virtual void printError(){
		cout << "空指针异常!" << endl;
	}
};
//越界异常
class OutOfRangeException : public BaseException{
public:
	virtual void printError(){
		cout << "越界异常!" << endl;
	}
};

void doWork(){

	throw NullPointerException();
}

void test()
{
	try{
		doWork();
	}
	catch (BaseException& ex){
		ex.printError();
	}
	
}


int _tmain(int argc, _TCHAR* argv[])
{
	test();
	return 0;
}

标准异常库

标准异常类的成员：
① 在上述继承体系中，每个类都有提供了构造函数、复制构造函数、和赋值操作符重载。
② logic_error类及其子类、runtime_error类及其子类，它们的构造函数是接受一个string类型的形式参数，用于异常信息的描述
③ 所有的异常类都有一个what()方法，返回const char* 类型（C风格字符串）的值，描述异常信息。

编写异常类