1、C++异常处理
(1)C++内置了异常处理的语法元素，try...catch...，这是两个新的关键字在C++中
@1：try语句代码块中用来处理正常代码逻辑
@2：catch语句代码块中用来处理异常情况
@3：try语句中的异常由对应的catch语句进行处理
try
{
douuble r = divide(1, 0);
}
catch(...)
{
cout << "Divide by zero..." << endl;
}
@4：try语句代码块中用来处理可能发生异常的正常逻辑代码，当try代码块中的代码发生了异常，就会抛出异常，catch语句就会捕捉到这个异常，进入到catch语句中进行处理这个异常。
(2)那么try代码块中的语句中是如何抛出异常的呢？
@1：C++通过throw关键字抛出异常信息
如：使用throw语句进行异常抛出
double divide(double a, double b)
{
const double delta = 0.000000000001;
double ret = 0;
if ( !((-delta < b) && (b < delta)) )
{
ret = a / b;
}
else
{
throw 0; //产生除0异常，这里是0这个字面常量来代码了当前的异常元素，异常元素可以是字符串，可以是对象，可以是一个值等等
//当程序执行到throw时，就会返回到调用这个divide函数的调用点，try就会将这个异常元素转给catch语句，catch语句块就会抓住这个异常元素
}
return ret;
}
2、C++异常处理分析
(1)throw抛出的异常必须被catch处理
@1：当前函数能够处理异常，程序继续往下执行
@2：当前函数如果无法处理收到的异常，则函数停止执行，并返回
(2)未被处理的异常会顺着函数调用栈向上传播，直到被处理为止，否则程序将停止执行。
比如:如果function1函数调用了function2函数，function2函数调用了function3函数，在function3函数中执行执行，并抛出了异常，也就是throw了，那么这个异常就会先看function3这个函数有没有能力处理这个异常(也就是在没在try中，有没有对应的catch处理的异常类型)，如果有就进行异常处理了，如果没有function3这个函数就会立即停止执行，并代码着异常返回给function2调用function3函数的调用点，如果function2没有进行处理（没有在try中，也没有catch处理的相关类型），function2就会立即停止执行，带着异常返回给function1函数调用function2函数的调用点。如果都没有对throw扔出的这个异常元素进行异常处理的话（函数调用没在try中也没有对应的catch异常处理的相关类型），整个程序就会放弃执行
例：throw抛出异常，对异常进行处理，try...catch
#include <iostream>
#include <string>
using namespace std;
double divide(double a, double b)
{
const double delta = 0.00000000001;
double ret = 0;
if ( !((-delta < b) && (b < delta)) )
{
ret = a / b;
}
else
{
throw 0; //产生除0异常，这里是0这个int类型的值来代码了当前的异常元素，异常元素可以是字符串，可以是对象，可以是一个值等等
//当程序执行到throw时，就会返回到调用这个divide函数的调用点，try就会将这个异常元素转给catch语句，catch语句块就会抓住这个异常元素 //如果没有对应的catch对这个异常进行处理，程序将会放弃执行
}
return ret;
}
int main(int argc, char *argv[])
{
double num = 0;
try
{
num = divide(1, 1); //执行到divide函数throw语句时，就会返回throw语句后面的异常元素给这个try，这个try将异常元素给了catch，catch对这个异常进行处理。
//如果没有对异常进行处理的操作，但你throw还抛出了异常，程序会停止运行
cout << "num = " << num << endl;
}
catch(...)
{
cout << "Divide by zero ...." << endl;
}
return 0;
}
(3)同一个try语句可以跟上多个catch语句
@1：catch语句可以定义具体处理的异常类型
@2：不同类型的异常由不同的catch语句负责处理
@3：try语句中可以抛出任何类型的异常
@4：catch(...)用于处理所有类型的异常，并且这个catch(...)里面是3个点的catch语句块只能放在最后catch处理的情况，当有其他catch存在时。
@5：任何异常都只能被捕获（catch）一次
(4)异常处理的匹配原则
try
{
throw 1;
}
catch (Type1 t1)
{
}
catch (Type2 t2)
{
}
catch (TypeN tn)
{
}
catch (...) //这个catch，处理任何类型的异常，当有其他catch存在时，只能作为最后的catch处理情况
{
}
异常抛出后，至上而下严格的匹配每一个catch语句处理的类型。异常处理匹配时，不进行任何的类型转换。所以是严格匹配的。
如果当前抛出异常的函数没有对这个异常处理，就会沿着当前函数的调用栈，顺序的返回，直到被处理，如果都没有进行这个异常处理，程序就会停止执行
例：一个try抛出异常，多个catch进行异常类型匹配处理异常的情况
#include <iostream>
#include <string>
/*
*一个try中抛出异常，多个catch进行匹配，
*匹配原则是严格的类型匹配，不会进行类型的转换，
*至上而下的进行匹配catch中的类型，catch(...)只能放在对try中抛出异常的处理最后
*/
using namespace std;
void Demo1()
{
try
{
throw 0; //直接抛出异常，这个是int类型的
}
catch (char c)
{
cout << "catch (char c)" << endl;
}
catch (double d)
{
cout << "catch (double d)" << endl;
}
catch (string s)
{
cout << "catch (string s)" << endl;
}
catch (int i)
{
cout << "catch (int i)" << endl;
}
catch (...)
{
cout << "catch (...)" << endl;
}
}
void Demo2()
{
try
{
throw "haha"; //这个const char* 类型的
}
catch (char *s)
{
cout << "catch (char *s)" << endl;
}
catch (string ss)
{
cout << "catch (string ss)" << endl;
}
catch (const char * cs)
{
cout << "catch (const char * cs)" << endl;
}
}
int main(int argc, char *argv[])
{
Demo1();
try
{
Demo2();
}
catch (...)
{
cout << "catch (...)" << endl;
}
return 0;
}
最后的执行结果，会打印catch (int i)和catch (...)
3、catch语句块中也可以抛出异常
try
{
func();
}
catch(int i)
{
throw i; //将捕获到的异常重新抛出。
}
catch(...)
{
throw; //将捕获到的异常重新抛出
}
catch中抛出的异常需要外层的try...catch...捕获。
(1)C++中之所以支持catch语句块中抛出异常，是因为我们在工程开发中，会经常的使用第三方库进行开发，如果第三方库中的func函数在使用时有可能会抛出异常，并且抛出的异常是-1,-2，-3等int类型异常，每一个异常元素对应的意思可以看第三方库中的文档来知道，但是我们在开发中，如果真遇到了第三方库抛出了异常，但是我们确无法直观的直接从这几个-1，-2，-3异常元素来知道每一个异常元素对应的是什么情况，只能去查第三方库提供的文档来知道，这是很浪费时间的，所以我们为了开发效率，所以我们将会将第三方库抛出的异常，进行统一的封装，也就是将func函数在我们自己写的Myfunc函数中调用，在Myfunc函数中，我们将第三方库func函数中可能抛出的异常元素进行重解释在抛出，这样我们就可以在工程开发中直接处理Myfunc这个函数抛出的重解释了第三方库func函数中抛出的异常。方便处理。
例：工程中在catch中抛出异常的用法，用于将第三方库中提供的函数抛出的异常进行重解释。
#include <iostream>
#include <string>
using namespace std;
/*
假设：func函数是第三方库中提供的函数，这个函数我们是无法修改的，因为我们得不到源码一般情况下
一般情况下，我们用的是第三方库提供的动态链接库。
func函数会抛出异常：
-1： 表示参数异常了
-2： 运行异常
-3： 超时异常
当这个func函数抛出异常的时候，我们无法直观的从它抛出的异常来知道究竟是发生了什么情况，只能去查阅第三方的文档。
所以为了方便，也为了架构的考虑，因为我们开发时，一般还有自己的私有库，所以我们就会对这个第三方库函数的异常进行重解释处理。
处理方法，就是我们自己写一个MyFunc函数，这个函数中调用了这个第三方库func函数，对这个func函数可能会抛出的异常进行重解释处理。
这样，我们的工程在使用func函数出现异常的时候，就只是针对于Myfunc我们自己写的这个函数的异常，同时异常的意思也被我们重解释的更清晰了
*/
void func(int i)
{
if (i < 10)
{
throw -1;
}
else if (i == 11)
{
throw -2;
}
else if (i > 100)
{
throw -3;
}
}
void MyFunc(int i) //自己提供的函数，完成和func一样的功能，只是为了重解释一下第三方库func函数抛出的异常
{
try
{
func(i);
}
catch (int i)
{
switch (i) //对第三方func函数抛出的异常进行重解释。
{
case -1:
throw "Invalid Exception";
break;
case -2:
throw "Run Exception";
break;
case -3:
throw "Timeout Exceptin";
break;
}
}
}
int main(void)
{
try
{
MyFunc(101);
}
catch (const char *cs)
{
cout << "Exception Info: " << cs << endl;
}
return 0;
}
4、异常的类型可以是自定义的类类型
(1)对于类类型的匹配依然是至上而下的严格匹配
(2)赋值兼容性原则在异常匹配中依然适用（子类的异常对象，可以被父类的catch语句块抓住）
(3)所以一般而言：
@1：匹配子类异常的catch放在上部
@2：匹配父类异常的catch放在下部
(5)在工程中会定义一系列的异常类
@1：每个类代表工程中可能出现的一种异常类型
@2：代码复用 时可能需要重解释不同的异常类
@3：在定义catch语句块时如果使用的异常是类对象，那么推荐使用引用作为参数，因为这样可以避开拷贝构造，提高程序效率
例：用异常类对异常进行重解释
#include <iostream>
#include <string>
using namespace std;
/*
工程中一般会常使用异常类，自定义一个异常类，来表示出现异常时的详细信息
*/
class Base
{
};
class Exception : public Base //继承了Base，所以catch接受这个类抛出的异常时，catch接受这个父类的异常处理要放到后面
{
private:
int m_id; //异常的ID号，也就是第三方库func函数中抛出异常的异常元素号。
string m_desc; //异常的信息描述
public:
Exception(int id, string desc)
{
m_id = id;
m_desc = desc;
}
int id() const
{
return m_id;
}
string description() const
{
return m_desc;
}
};
/*
假设：func函数是第三方库中提供的函数，这个函数我们是无法修改的，因为我们得不到源码一般情况下
一般情况下，我们用的是第三方库提供的动态链接库。
func函数会抛出异常：
-1： 表示参数异常了
-2： 运行异常
-3： 超时异常
当这个func函数抛出异常的时候，我们无法直观的从它抛出的异常来知道究竟是发生了什么情况，只能去查阅第三方的文档。
所以为了方便，也为了架构的考虑，因为我们开发时，一般还有自己的私有库，所以我们就会对这个第三方库函数的异常进行重解释处理。
处理方法，就是我们自己写一个MyFunc函数，这个函数中调用了这个第三方库func函数，对这个func函数可能会抛出的异常进行重解释处理。
这样，我们的工程在使用func函数出现异常的时候，就只是针对于Myfunc我们自己写的这个函数的异常，同时异常的意思也被我们重解释的更清晰了
*/
void func(int i)
{
if (i < 10)
{
throw -1;
}
else if (i == 11)
{
throw -2;
}
else if (i > 100)
{
throw -3;
}
}
void MyFunc(int i) //自己提供的函数，完成和func一样的功能，只是为了重解释一下第三方库func函数抛出的异常
{
try
{
func(i);
}
catch (int i)
{
switch (i) //对第三方func函数抛出的异常进行重解释。
{
case -1:
throw Exception(-1, "Invalid Exception");
break;
case -2:
throw Exception(-2, "Run Exception");
break;
case -3:
throw Exception(-3, "Timeout Exceptin");
break;
}
}
}
int main(void)
{
try
{
MyFunc(111);
}
catch (const Exception& e)
{
cout << "Exception Info: " << endl;
cout << "ID: " << e.id() << endl;
cout << "Description: " << e.description() << endl;
}
catch (const Base& e) //父类的接受异常要放到后面，因为赋值兼容性原则，如果这个接受异常放在了前面，那么抛出的异常就会被父类接受到了
{
cout << "catch (const Base& e)" << endl;
}
return 0;
}
6、C++标准库中提供了实用异常类族，使用时要包含<stdexcept>这个头文件，并且要声明使用的命名空间是std
(1)标准库中的异常都是从exception顶层父类派生的
(2)exception类有两个主要分支，在于异常的类型是不一样的
@1：logic_error
常用于程序中的可避免逻辑错误，（out_of_range("可以有参数，字符串参数，只是哪个函数发生的异常");数组访问越界，参数错误等）
@2：runtime_error
常用于程序中无法避免的恶性错误（）