一篇文章带你了解C++中的异常

int myDivision(int a, int b)
{
	if (b == 0)
	{
		throw -1;//抛出-1
	}
	else
		return 1;
}
int main()
{
	int a = 10;
	int b = 0;
	try 
	{
		myDivision(a, b);
	}
	catch (int)
	{
		cout << "int类型异常捕获" << endl;
	}
	return 0;
}

catch (...)
	{
		cout << "其他类型异常捕获" << endl;
	}

int myDivision(int a, int b)
{
	if (b == 0)
	{
		throw -1;
	}
}
void test()
{
	int a = 10;
	int b = 0;
	try
	{
		myDivision(a, b);
	}
	catch (int)
	{
		throw;
	}
}
int main()
{
	try 
	{
		test();
	}
	catch (int)
	{
		cout << "int类型异常捕获" << endl;
	}
	return 0;
}  

class MyException
{
public:
	void printError()
	{
		cout << "我自己的异常" << endl;
	}
};
int myDivision(int a, int b)
{
	if (b == 0)
	{
		throw  MyException();//类名加（）就是匿名对象,抛出的就是匿名对象。
	}
}
int main()
{
	int a = 10;
	int b = 0;
	try
	{
		myDivision(a, b);
	}
	catch (MyException e)
	{
		e.printError();//可以直接用这个对象来调用成员函数
	}
	return 0;
}

class Person
{
public:
	Person()
	{
		cout << "Person的默认构造调用" << endl;
	}
	~Person()
	{
		cout << "Person的析构调用" << endl;
	}
};
int myDivision(int a, int b)
{
	if (b == 0)
	{
		Person p1;
		Person p2;
		throw  Person();//匿名对象
	}
}
int main()
{
	int a = 10;
	int b = 0;
	try
	{
		myDivision(a, b);
	}
	catch (Person)
	{
		cout << "拿到Person类异常,正在处理" << endl;
	}
	return 0;
}

//异常接口的声明
void func() throw(int , double)//只允许抛出int和double类型的异常。
{
	throw 3.14;
}
int main()
{
	try
	{
		func();
	}
	catch (int)
	{
		cout << "int类型异常捕获" << endl;
	}
	catch (...)
	{
		cout << "其他类型异常捕获" << endl;
	}
	return 0;
}

class MyException
{
public:
	MyException()
	{
		cout << "MyException的默认构造调用" << endl;
	}
	MyException(const MyException&e)
	{
		cout << "MyException的拷贝构造调用" << endl;
	}
	~MyException()
	{
		cout << "MyException的析构调用" << endl;
	}
};
void doWork()
{
	throw MyException();//抛出匿名对象
}
int main()
{
	try
	{
		doWork();
	}
	catch (MyException e)
	{
		cout << "自定义异常的捕获" << endl;	
	}
	return 0;
}

catch (MyException &e)
	{
		cout << "自定义异常的捕获" << endl;	
	}

MyException的默认构造调用
自定义异常的捕获
MyException的析构调用

class MyException
{
public:
	MyException()
	{
		cout << "MyException的默认构造调用" << endl;
	}
	MyException(const MyException&e)
	{
		cout << "MyException的拷贝构造调用" << endl;
	}
	~MyException()
	{
		cout << "MyException的析构调用" << endl;
	}
};
void doWork()
{
	throw & MyException();//抛出匿名对象
}
int main()
{
	try
	{
		doWork();
	}
	catch (MyException *e)
	{
		cout << "自定义异常的捕获" << endl;	
	}
	return 0;
}

void doWork()
{
	throw new MyException();//抛出匿名对象
}

//异常的基类
class BaseException
{
public:
	virtual void printError() = 0;//纯虚函数
};
//空指针异常
class NULLPointerException:public BaseException
{
public:
	virtual void printError()
	{
		cout << "空指针异常" << endl;
	}
};
//越界异常
class outOfRangeException :public BaseException
{
public:
	virtual void printError()
	{
		cout << "越界异常" << endl;
	}
};
void doWork()
{
	//throw NULLPointerException();
	throw outOfRangeException();
}
int main()
{
	try
	{
		doWork();
	}
	catch (BaseException &e)//用父类的引用接收子类的对象
	{
		e.printError();
	}
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1
#include<iOStream>
using namespace std;
#include<string>
#include<stdexcept>
class Person
{
public:
	Person(int age)
	{
		if (age < 0 || age>150)
		{
			throw out_of_range("年龄必须在0-150之间");
		}
	}
	int m_age;
};
int main()
{
	try
	{
		Person p(151);
	}
	catch (out_of_range&e)
	{
		cout << e.what() << endl;//what函数是获得字符串中的内容
	}
	return 0;
	//如果使用多态：（异常子类的名字太难记，不好写）
	//catch (exception &e)
}

const char* what() const
{
    string s;
    return s.c_str();
    //返回的就是const char*了。
}

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<string>
#include<stdexcept>
class MyOutOfRangeException:public exception//先继承一下这个父亲
{
	//到底要重写什么呢？点开exception以后，发现有两个virtual的虚函数，一个析构，还有一个what，析构不需要重写
	//所以需要重写what函数。
public:
	MyOutOfRangeException(const char* str)
	{
		//const char*可以隐式类型转换为string 反之不可以
		this->m_myerrorString = str;
	}
	//可以再重载一下这个函数，使得接收的参数改为string类型
	MyOutOfRangeException(string str)
	{
		this->m_myerrorString = str;
	}
	virtual char const* what() const
	{
		return m_myerrorString.c_str();//加了.c_str就可以返回const char*了
	}
	string m_myerrorString;//字符串属性
};
class Person
{
public:
	Person(int age)
	{
		if (age < 0 || age>150)
		{
			throw MyOutOfRangeException("年龄必须在0-150之间");//const char*
			throw MyOutOfRangeException(string("年龄必须在0-150之间"));//string，返回的是string类的匿名对象
		}
		else
		{
			this->m_age = age;
		}
	}
	int m_age;
};
int main()
{
	try
	{
		Person p(1000); 
	}
	catch (MyOutOfRangeException e)//用exception也可以，证明创建的这个类确实是exception的子类。
	{
		cout << e.what() << endl;
	}
	return 0;
}