C++学习笔记：异常的基本语法

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

2）将可能抛出异常的程序段嵌在try块之中。控制通过正常的顺序执行到达try语句。然后执行try块内的保护段

3）如果在保护段执行期间没有引起异常，那么跟在try块后的catch子句就不执行。程序从try块后跟随的最后一个catch子句后面的语句继续执行下去

4）catch子句按其在try块后出现的顺序被检查。匹配的catch子句将捕获并处理异常（或继续抛出异常）

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

6）处理不了的异常，可以在catch的最后一个分支，使用throw语法，向上扔

// 异常的基本语法.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>

using namespace std;

void divide(int x,int y){
	if (y == 0){
		throw x;//抛出 int 类型异常 
		//异常直接跨越函数，类似于return语句，不执行接下来的语句
	}
	cout << "divide结果：" << x / y << endl;
}

void myDivide(int x, int y){
	try{
		divide(x, y);
	}
	catch (...){
		cout << "我接受了divide的异常，但是我没有处理，我继续向上抛出" << endl;
		throw;//接受异常后可以不处理，继续抛出
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	try{
		divide(10 , 2);
		divide(100 , 0);
		//myDivide(1, 0);//跨越函数的实验
	}
	catch (int e){
		cout << e << "被零整除" << endl;
	}
	catch (...){//其他未知类型的异常
		cout << "其他未知类型异常" << endl;
	}

	return 0;
}

2.栈解旋

执行throw语句后，相当于 return ，但是不是，会调用析构函数 释放掉栈空间

// 异常_栈解旋.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>

using namespace std;

class Test{
public:
	Test(int a = 0, int b = 0){
		this->a = a;
		this->b = b;
		cout << "构造函数do" << endl;
	}
	~Test(){
		cout << "析构函数do\n";
	}
private:
	int a;
	int b;
};

void myDivide(){
	Test t1(1, 2), t2(3, 4);
	cout << "myDivide 要发生异常啦~ " << endl;
	throw 1;
}

int _tmain(int argc, _TCHAR* argv[])
{
	try{
		myDivide();
	}
	catch (int a){
		cout << "int型异常" << endl;
	}
	catch (...){
		cout << "未知异常" << endl;
	}
	return 0;
}

3.异常的接口声明

1）为了加强程序的可读性，可以在函数声明中列出可能抛出的所有异常累成，例如：

void func() throw(A,B,C,D);//这个函数func()能够且只能抛出类型A B C D及其子类型的异常

2）如果在函数声明中没有包含异常接口声明，则该函数可以抛出任何类型的异常，例如：

void func();

3）一个不抛出任何类型异常的函数可以声明为：

void func() throw();

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

4.异常变量的声明周期

// 异常_栈解旋.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>

using namespace std;

class BadSrcType{
public:
	BadSrcType(){
		cout << "BadSrcType构造函数do" << endl;
	}
	BadSrcType(const BadSrcType &obj){
		cout << "BadSrcType拷贝构造函数do" << endl;
	}
	~BadSrcType(){
		cout << "BadSrcType析构函数do\n";
	}
};

class BadDesType{
public:
	BadDesType(){
		cout << "BadDesType构造函数do" << endl;
	}
	BadDesType(const BadDesType &obj){
		cout << "BadDesType拷贝构造函数do" << endl;
	}
	~BadDesType(){
		cout << "BadDesType析构函数do\n";
	}
};

class BadProType{
public:
	BadProType(){
		cout << "BadProType构造函数do" << endl;
	}
	BadProType(const BadProType &obj){
		cout << "BadProType拷贝构造函数do" << endl;
	}
	~BadProType(){
		cout << "BadProType析构函数do\n";
	}
};

void my_strcpy(char *to,char *from){
	if (from == NULL){
		throw BadSrcType();//会产生一个匿名对象
	}
	if (to == NULL){
		throw BadDesType();
	}
	
	if (*from=='a'){
		cout << "开始BadProType类型异常" << endl;
		throw BadProType();//适用于方式一和二
		//throw new BadProType;//适用于方式三
	}
	while (*from!='\0'){
		*to = *from;
		to++;
		from++;
	}
	*to = '\0';
}

int main()
{
	int ret = 0;
	char buf1[] = "abcdefg";
	char buf2[1024] = { 0 };
	try{
		my_strcpy(buf2,buf1);
	}
	//结论1：如果接收异常的时候使用异常变量 则进行拷贝构造异常变量
	catch (BadSrcType e){//接匿名对象，并初始化e，此时匿名对象转正，不会调用匿名对象的析构函数
		cout << "BadSrcType类型异常" << endl;
	}
	catch (BadDesType e){
		cout << "BadDesType类型异常" << endl;
	}
	catch (BadProType e){
		cout << "BadProType类型异常" << endl;
	}
	catch (...){
		cout << "未知异常" << endl;
	}
	//方式二：用引用接收异常
	//结论二：使用引用的话 会使用throw时候的那个对象
	//catch (BadSrcType &e){//接匿名对象，并初始化e，此时匿名对象转正，不会调用匿名对象的析构函数
	//	cout << "BadSrcType类型异常" << endl;
	//}
	//catch (BadDesType &e){
	//	cout << "BadDesType类型异常" << endl;
	//}
	//catch (BadProType &e){
	//	cout << "BadProType类型异常" << endl;
	//}
	//catch (...){
	//	cout << "未知异常" << endl;
	//}
	//方式三：用指针来接
	//结论三：指针可以和引用/元素 写在一块，但是元素和引用不能写在一块
	//catch (BadSrcType *e){//接匿名对象，并初始化e，此时匿名对象转正，不会调用匿名对象的析构函数
	//	cout << "BadSrcType类型异常" << endl;
	//	delete e;//在底层函数里new，在上层函数里delete。不安全
	//}
	//catch (BadDesType *e){
	//	cout << "BadDesType类型异常" << endl;
	//	delete e;
	//}
	//catch (BadProType *e){
	//	cout << "BadProType类型异常" << endl;
	//	delete e;
	//}
	//catch (...){
	//	cout << "未知异常" << endl;
	//}
	//结论：最适合的方法是用引用来接
	return 0;
}

方式一：

方式二：

方式三：