Day08C++(中)异常

1 异常基本概念

基本思想是：让一个函数在发现了自己无法处理的错误时抛出（throw）一个异常，然后它的（直接或者间接）调用者能够处理这个问题。

一句话：异常处理就是处理程序中的错误。所谓错误是指在程序运行的过程中发生的一些异常事件（如：除0溢出，数组下标越界，所要读取的文件不存在,空指针，内存不足等等）。

在C语言的世界中，对错误的处理总是围绕着两种方法：一是使用整型的返回值标识错误；二是使用errno宏（可以简单的理解为一个全局整型变量）去记录错误。当然C++中仍然是可以用这两种方法的。

        这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回1表示成功，返回0表示出错；而有些函数返回0表示成功，返回非0表示出错。

        还有一个缺点就是函数的返回值只有一个，你通过函数的返回值表示错误代码，那么函数就不能返回其他的值。当然，你也可以通过指针或者C++的引用来返回另外的值，但是这样可能会令你的程序略微晦涩难懂。

C++处理异常的优势相比C语言有什么优势？

1>  函数的返回值可以忽略，但异常不可忽略。如果程序出现异常，但是没有被捕获，程序就会终止，这多少会促使程序员开发出来的程序更健壮一点。而如果使用C语言的error宏或者函数返回值，调用者都有可能忘记检查，从而没有对错误进行处理，结果造成程序莫名其面的终止或出现错误的结果。

2>  整型返回值没有任何语义信息。而异常却包含语义信息，有时你从类名就能够体现出来。

3>  整型返回值缺乏相关的上下文信息。异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息。

4>  异常处理可以在调用跳级。这是一个代码编写时的问题：假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求你在每一级函数中都要进行处理。而使用异常处理的栈展开机制，只需要在一处进行处理就可以了，不需要每级函数都处理。

2 异常语法

1.异常的基本语法：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

int myDivide(int a,int b){
	if (b == 0){
		throw 'c'; //抛出一个int类型异常
	}

	return a / b;
}

void test01(){
	
	int a = 10;
	int b = 0;
	try{  //试着去执行try语句块中代码，如果有异常则捕获
		myDivide(a, b);
	}
	catch (int){  //捕获异常，根据类型严格匹配
		cout << "捕获int类型异常!" << endl;
	}
	catch (char e){ //捕获所有异常
		throw; //虽然捕获了，但是我不处理不了，继续上抛异常
		//cout << "捕获其他异常:" << e << endl;
	}

}

//c++的异常机制是通过类型来匹配的
//抛出异常用throw关键字 + 值
//通过try{}catch{}来捕获异常

int main(){

	try{
		test01(); //异常如果不处理的话，会调用terminate函数
	}
	catch (char){
		cout << "在main函数中捕获char类型异常!" << endl;
	}
	

	system("pause");
	return EXIT_SUCCESS;
}

总结:

1> 若有异常则通过throw操作创建一个异常对象并抛出。

2> 将可能抛出异常的程序段放到try块之中。

3> 如果在try段执行期间没有引起异常，那么跟在try后面的catch字句就不会执行。

4> catch子句会根据出现的先后顺序被检查，匹配的catch语句捕获并处理异常(或继续抛出异常)

5> 如果匹配的处理未找到，则运行函数terminate将自动被调用，其缺省功能调用abort终止程序。

6> 处理不了的异常，可以在catch的最后一个分支，使用throw，向上抛。

 

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

2.异常的严格类型匹配

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

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


//1. 异常严格类型匹配
class MyException{
public:
	void printError(){
		cout << "我的异常!" << endl;
	}
};

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

void doBussiness(){

	//throw 10; //抛出int类型
	//throw "abc"; //抛出char*类型异常

	//string ex = "abc";
	//throw ex;
	//throw MyException(); //抛出自定义对象异常

	Person p1;
	Person p2;

	throw 'a';
}

void test01(){
	
	try{
		doBussiness();
	}
	catch (int e){
		cout << "int类型异常:" << e << endl;
	}
	catch (char* e){
		cout << "char*类型异常:" << e << endl;
	}
	catch (string e){
		cout << "string类型异常:" << e << endl;
	}
	catch (MyException e){
		e.printError();
	}
	catch (...){
		cout << "捕获其他异常!" << endl;
	}

}

int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

3.栈解旋（unwinding）

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

4.异常接口声明

1>为了加强程序的可读性，可以在函数声明中列出可能抛出异常的所有类型，例如：void func() throw(A,B,C);这个函数func能够且只能抛出类型A,B,C及其子类型的异常。

2> 如果在函数声明中没有包含异常接口声明，则此函数可以抛任何类型的异常，例如:void func()

3> 一个不抛任何类型异常的函数可声明为:void func() throw()

4> 如果一个函数抛出了它的异常接口声明所不允许抛出的异常,unexcepted函数会被调用，该函数默认行为调用terminate函数中断程序。

5.异常变量声明周期

1> throw的异常是有类型的，可以是数字、字符串、类对象。

2> throw的异常是有类型的，catch需严格匹配异常类型。

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

//目标空间为空异常
class TargetSpaceNullException : public AbstractException{
public:
	TargetSpaceNullException(){
		cout << "TargetSpaceNullException Constrctor!" << endl;
	}
	TargetSpaceNullException(const TargetSpaceNullException&){
		cout << "TargetSpaceNullException Copy Constructor!" << endl;
	}
	virtual void printError(){
		cout << "Taget Space Null Exception!" << endl;
	}
	~TargetSpaceNullException(){
		cout << "TargetSpaceNullException Destructor!" << endl;
	}
};

//源空间为空异常
class SourceSpaceNullException : public AbstractException{
public:
	SourceSpaceNullException(){
		cout << "SourceSpaceNullException Constrctor!" << endl;
	}
	SourceSpaceNullException(const SourceSpaceNullException&){
		cout << "SourceSpaceNullException Copy Constructor!" << endl;
	}
	virtual void printError(){
		cout << "Source Space Null Exception!!" << endl;
	}
	~SourceSpaceNullException(){
		cout << "SourceSpaceNullException Destructor!" << endl;
	}
	int a;
};


void Copy_String(char* dest, char* source){

	if (dest == NULL){
		throw TargetSpaceNullException();
	}

	if (source == NULL){
		throw SourceSpaceNullException();
	}

	while (*source != '0'){
		*dest = *source;
		dest++;
		source++;
	}
}

//元素方式
void test01(){

	//字符串拷贝
	char* sourceSpace = "abcdefgh";
	//目标空间
	char destSpace[1024] = { 0 };
	//拷贝
	try{
		Copy_String(destSpace, NULL);
	}
	catch (TargetSpaceNullException ex){
		ex.printError();
	}
	catch (SourceSpaceNullException ex){
		ex.printError();
	}

	cout << "destSpace:" << destSpace << endl;
}

//引用方式
void test02(){

	//字符串拷贝
	char* sourceSpace = "abcdefgh";
	//目标空间
	char destSpace[1024] = { 0 };
	//拷贝
	try{
		Copy_String(destSpace, NULL);
	}
	catch (TargetSpaceNullException& ex){
		ex.printError();
	}
	catch (SourceSpaceNullException& ex){
		ex.printError();
	}

	cout << "destSpace:" << destSpace << endl;
}

//指针方式
void test03(){

	//字符串拷贝
	char* sourceSpace = "abcdefgh";
	//目标空间
	char destSpace[1024] = { 0 };
	//拷贝
	try{
		Copy_String(destSpace, NULL);
	}
	catch (TargetSpaceNullException* ex){
		ex->printError();

	}
	catch (SourceSpaceNullException* ex){
		ex->printError();
	}

	cout << "destSpace:" << destSpace << endl;
}


void test04(){

	//字符串拷贝
	char* sourceSpace = "abcdefgh";
	//目标空间
	char destSpace[1024] = { 0 };
	//拷贝
	try{
		Copy_String(destSpace, NULL);
	}
	catch (AbstractException& ex){
		ex.printError();
	}

	cout << "destSpace:" << destSpace << endl;
}

6.C++标准异常库

标准库中也提供了很多的异常类，它们是通过类继承组织起来的。异常类继承层级结构图如下：

标准异常类的成员：

① 在上述继承体系中，每个类都有提供了构造函数、复制构造函数、和赋值操作符重载。

② logic_error类及其子类、runtime_error类及其子类，它们的构造函数是接受一个string类型的形式参数，用于异常信息的描述

③ 所有的异常类都有一个what()方法，返回constchar* 类型（C风格字符串）的值，描述异常信息。

标准异常类的具体描述：

异常名称	描述
exception	所有标准异常类的父类
bad_alloc	当operator new and operator new[]，请求分配内存失败时
bad_exception	这是个特殊的异常，如果函数的异常抛出列表里声明了bad_exception异常，当函数内部抛出了异常抛出列表中没有的异常，这是调用的unexpected函数中若抛出异常，不论什么类型，都会被替换为bad_exception类型
bad_typeid	使用typeid操作符，操作一个NULL指针，而该指针是带有虚函数的类，这时抛出bad_typeid异常
bad_cast	使用dynamic_cast转换引用失败的时候
ios_base::failure	io操作过程出现错误
logic_error	逻辑错误，可以在运行前检测的错误
runtime_error	运行时错误，仅在运行时才可以检测的错误

logic_error的子类：

异常名称	描述
length_error	试图生成一个超出该类型最大长度的对象时，例如vector的resize操作
domain_error	参数的值域错误，主要用在数学函数中。例如使用一个负值调用只能操作非负数的函数
out_of_range	超出有效范围
invalid_argument	参数不合适。在标准库中，当利用string对象构造bitset时，而string中的字符不是’0’或’1’的时候，抛出该异常

runtime_error的子类：

异常名称	描述
range_error	计算结果超出了有意义的值域范围
overflow_error	算术计算上溢
underflow_error	算术计算下溢
invalid_argument	参数不合适。在标准库中，当利用string对象构造bitset时，而string中的字符不是’0’或’1’的时候，抛出该异常

 

#include<stdexcept>
class Person{
public:
	Person(int age){
		if (age < 0 || age > 150){
			throw out_of_range("年龄应该在0-150岁之间!");
		}
	}
public:
	int mAge;
};

int main(){

	try{
		Person p(151);
	}
	catch (out_of_range& ex){
		cout << ex.what() << endl;
	}
	
	system("pause");
	return EXIT_SUCCESS;
}

7.编写自己的异常类

① 标准库中的异常是有限的；

② 在自己的异常类中，可以添加自己的信息。（标准库中的异常类值允许设置一个用来描述异常的字符串）。

如何编写自己的异常类？

① 建议自己的异常类要继承标准异常类。因为C++中可以抛出任何类型的异常，所以我们的异常类可以不继承自标准异常，但是这样可能会导致程序混乱，尤其是当我们多人协同开发时。

② 当继承标准异常类时，应该重载父类的what函数和虚析构函数。

③ 因为栈展开的过程中，要复制异常类型，那么要根据你在类中添加的成员考虑是否提供自己的复制构造函数。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<stdexcept>
#include<string>
using namespace std;


//编写自己的异常类
class MyOutOfRange : public exception{
public:
	MyOutOfRange(const char* errorInfo){
		pInfo = new char[strlen(errorInfo) + 1];
		strcpy(pInfo, errorInfo);
	}
	MyOutOfRange(const MyOutOfRange& my){
		this->pInfo = new char[strlen(my.pInfo) + 1];
		strcpy(pInfo, my.pInfo);
	}
	virtual const char *  what() const{
		return pInfo;
	}
	 virtual  ~MyOutOfRange() _NOEXCEPT{}
private:
	char* pInfo;
};


class Person{
public:
	void setName(string name){
		this->mName = name;
	}
	void setAge(int age){
		if (age < 0 || age > 100){
			//throw out_of_range("年龄范围:0-100!");
			throw MyOutOfRange("年龄范围:0-100!");
		}
		this->mAge = age;
	}
public:
	string mName;
	int mAge;
};

int main(){

	Person p;
	try{
		p.setName("Obama");
		p.setAge(150);
	}
	catch (exception& ex){
		cout << ex.what() << endl;
	}


	cout << "Name:" << p.mName << " Age:" << p.mAge << endl;


	system("pause");
	return EXIT_SUCCESS;
}