C++：异常

一.异常的基本概念

1.异常: 出错后,将出错问题返回给调用处
2.c语言的异常处理比较简单,容易出错（如下）,c++处理异常不容易出错

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string.h>
#include <string>
using namespace std;
int  mydive(int a, int  b)
{
	if (b == 0)
		return -1; //errno  = 2

	return  a / b;
}

void  test01()
{
	int ret = mydive(1, -1);
	if (ret == -1)
	{
		cout << "除数为0" << endl;//perror("");
	
	}
}

int  main() {

	test01();

}

二.C++处理异常

异常的基本语法：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string.h>
#include <string>
using namespace std;
int  mydive(int a, int  b)
{
	string str = "hello";
	if (b == 0)
		throw  str;//处理异常 抛出异常 抛出一个类型

	return  a / b;
}
void   test01()
{
	//尝试捕获异常
	try
	{
		mydive(2,0);
	}
	catch (char)//如果没有捕获的抛出的异常 程序会被终止
	{
		//cout << "捕获了一个char类型的异常" << endl;
		throw 'a';
	}
	catch (int)
	{
		cout << "捕获了一个int类型的异常" << endl;
	}
	catch (double)
	{
		cout << "捕获了一个double类型的异常" << endl;
	}
	catch (...)
	{
		cout << "捕获了一个其他类型的异常" << endl;
	}
}
int main()
{
	try {
		test01();
	}
	catch (char)
	{
		cout << "捕获了一个char类型的异常" << endl;
	}
}

三.栈解旋

在try到throw之间定义的对象,在throw之后会被释放

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string.h>
#include <string>
using namespace std;
class Person
{
public:
	Person(string name)
	{
		cout << "构造" << endl;
		this->name = name;
	}
	~Person()
	{
		cout << "析构" << endl;
	}
	string name;
};
void  fun()
{
	Person p2("bob");
	Person p3("peter");
	cout << "001" << endl;
	throw 1;
}

void test01()
{
	try
	{
		Person p1("lucy");
		fun();
	}
	catch (int)
	{
		cout << "002" << endl;
		cout << "捕获到异常" << endl;
	}

}

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

结果如下：

四.异常接口声明

一：可以抛掷A,B,C,D和子类型的异常

void fun() throw(A,B,C,D);

二：可以抛掷任意类型的异常

void fun();

三：不可以抛掷任意类型的异常

void fun) throw();

注意：如果抛掷的异常类型和声明的类型不一致，那么会调用unexpected函数，它的默认行为是调用terminate函数终止程序。

五.异常变量生命周期

抛出的匿名对象的生命周期在catch里面

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string.h>
#include <string>
using namespace std;
class Myexception
{
public:
	Myexception()
	{
		cout << "构造函数" << endl;
	}
	~Myexception()
	{
		cout << "析构函数" << endl;
	}
	void  error()
	{
		cout << "my  error" << endl;
	}

};
class Myexception1
{
public:
	Myexception1()
	{
		cout << "构造函数" << endl;
	}
	~Myexception1()
	{
		cout << "析构函数" << endl;
	}
	void  error()
	{
		cout << "my  error" << endl;
	}

};
void  fun()
{
	Myexception p1;
	//throw Myexception();//如果抛出匿名对象 他的声明周期在catch里面
	throw p1;/*p1生命周期在throw之前，实际抛出的是一个匿名对象，也就是说，在抛出的时候会创建一个匿名对象*/

}
void  test01()
{
	try {
		fun();

	}
	catch (Myexception &p)
	{
		p.error();
	}
	catch (Myexception1 &p)
	{
		p.error();
	}
}
int main()
{
	test01();
	return 0;
}

结果如下：

六.异常的多态使用

1.做法就是抛出任意一个子类，用父类引用或指针去接引
2.这样做的好处在于，当我们一个程序可能有多个类会抛出，这时可能要对各个类进行识别处理，会多次用到catch，这样的代码显得多且杂乱。这时我们只需要给各个类设定一个共同的基类，用虚函数实现异常的多态使用

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string.h>
#include <string>
using namespace std;
//基类
class Myexception
{
public:
	virtual void  error() = 0;
};

class Out_of_range:public Myexception
{
public:
	void  error()
	{
		cout << "Out_of_range" << endl;
	}
};

class Bad_cast :public Myexception
{
public:
	void  error()
	{
		cout << "Bad_cast" << endl;
	}
};
void fun()
{
	//throw Out_of_range();
	throw Bad_cast();
}
void  test01()
{
	try
	{
		fun();
	}
	catch (Myexception &p)
	{
		p.error();
	}
}
int  main()
{
	test01();
	return 0;
}

七.基于C++异常库编写自己的异常类

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string.h>
#include <string>
//exception
#include <stdexcept>
using namespace std;
class Longlongerror :public exception
{
public:
	Longlongerror(string  data)
	{
		this->data = data;
	}
	Longlongerror(char *  data)
	{
		this->data = data;
	}
	const char * what() const
	{
		 return data.c_str(); //将string类强制转换成从const char*
	}
	string  data;

};

void fun()
{
	throw Longlongerror("长长的错误");
}
void  test01()
{
	try
	{
		fun();
	}
	catch (exception &p)
	{
		cout << p.what() << endl;
	}
}
int  main()
{
	test01();
	return 0;
}