//如果判断返回值，那么返回值是错误码还是结果？
//如果不判断返回值，那么 b==0 时候，程序结果已经不正确
//A 写的代码
int A_MyDivide(int a,int b){if (b == 0){return -1;}return a / b;
}
//B 写的代码
int B_MyDivide(int a,int b){int ba = a + 100;int bb = b;int ret = A_MyDivide(ba, bb); //由于 B 没有处理异常，导致 B 结果运算错误return ret;
}
//C 写的代码
int C_MyDivide(){int a = 10;int b = 0;int ret = B_MyDivide(a, b); //更严重的是，由于 B 没有继续抛出异常，导致 C 的代码没有办法捕获异常if (ret == -1){return -1;}else{return ret;}
}
//所以,我们希望：
//1.异常应该捕获，如果你捕获，可以，那么异常必须继续抛给上层函数,你不处理，不
代表你的上层不处理
//2.这个例子，异常没有捕获的结果就是运行结果错的一塌糊涂，结果未知，未知的结果
程序没有必要执行下去

异常语法

int A_MyDivide(int a, int b){if (b == 0){throw 0;}return a / b;
}
//B 写的代码 B 写代码比较粗心，忘记处理异常
int B_MyDivide(int a, int b){int ba = a;int bb = b;int ret = A_MyDivide(ba, bb) + 100; //由于 B 没有处理异常，导致 B 结果运算错误return ret;
}
//C 写的代码
int C_MyDivide(){int a = 10;int b = 0;int ret = 0;//没有处理异常，程序直接中断执行#if 1 ret = B_MyDivide(a, b);//处理异常#elsetry{ret = B_MyDivide(a, b); //更严重的是，由于 B 没有继续抛出异常，导致 C 的代码没有办法捕获异常}catch (int e){cout << "C_MyDivide Call B_MyDivide 除数为:" << e << endl;}#endifreturn ret;
}
int main(){C_MyDivide();system("pause");return EXIT_SUCCESS;
}

 异常严格类型匹配

void TestFunction(){cout << "开始抛出异常..." << endl;//throw 10; //抛出 int 类型异常//throw 'a'; //抛出 char 类型异常//throw "abcd"; //抛出 char*类型异常string ex = "string exception!";throw ex;
}
int main(){try{TestFunction();}catch (int){cout << "抛出 Int 类型异常!" << endl;}catch (char){cout << "抛出 Char 类型异常!" << endl;}catch (char*){cout << "抛出 Char*类型异常!" << endl;}catch (string){cout << "抛出 string 类型异常!" << endl;}//捕获所有异常catch (...){cout << "抛出其他类型异常!" << endl;}system("pause");return EXIT_SUCCESS;
}

栈解旋(unwinding)

异常被抛出后，从进入 try 块起，到异常被抛掷前，这期间在栈上构造的所有对象，
都会被自动析构。析构的顺序与构造的顺序相反，这一过程称为栈的解旋
(unwinding).
public:Person(string name){mName = name;cout << mName << "对象被创建!" << endl;}~Person(){cout << mName << "对象被析构!" << endl;}
public:string mName;
};
void TestFunction(){Person p1("aaa");Person p2("bbb");Person p3("ccc");//抛出异常throw 10;
}
int main(){try{TestFunction();}catch (...){cout << "异常被捕获!" << endl;}system("pause");return EXIT_SUCCESS;
}

异常接口声明

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

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

如 :void func()

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

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

//可抛出所有类型异常
void TestFunction01(){throw 10;
}
//只能抛出 int char char*类型异常
void TestFunction02() throw(int,char,char*){string exception = "error!";throw exception;
}
//不能抛出任何类型异常
void TestFunction03() throw(){throw 10;
}
int main(){try{//TestFunction01();//TestFunction02();//TestFunction03();}catch (...){cout << "捕获异常!" << endl;}system("pause");return EXIT_SUCCESS;
}

请分别在 qt vs linux 下做测试 ! Qt and Linux 正确 !

异常变量生命周期

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

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

class MyException
{
public:MyException(){cout << "异常变量构造" << endl;}MyException(const MyException & e){cout << "拷贝构造" << endl;}~MyException(){cout << "异常变量析构" << endl;}
};
void DoWork()
{throw new MyException(); //test1 2 都用 throw MyExecption();
}
void test01()
{try{DoWork();}catch (MyException e){cout << "捕获 异常" << endl;}
}
void test02()
{try{DoWork();}catch (MyException &e){cout << "捕获 异常" << endl;}
}
void test03()
{try{DoWork();}catch (MyException *e){cout << "捕获 异常" << endl;delete e;}
}

异常的多态使用

//异常基类
class BaseException{
public:virtual void printError(){};
};
//空指针异常
class NullPointerException : public BaseException{
public:virtual void printError(){cout << "空指针异常!" << endl;}
};
//越界异常
class OutOfRangeException : public BaseException{
public:virtual void printError(){cout << "越界异常!" << endl;}
};
void doWork(){throw NullPointerException();
}
void test()
{try{doWork();}catch (BaseException& ex){ex.printError();}
}

C++标准异常库

标准库介绍

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

每个类所在的头文件在图下方标识出来。

标准异常类的成员：

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

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

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

标准异常类的具体描述：

#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;
}

编写自己的异常类

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

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

如何编写自己的异常类？

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

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

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

//自定义异常类
class MyOutOfRange:public exception
{
public:MyOutOfRange(const string errorInfo){this->m_Error = errorInfo;}MyOutOfRange(const char * errorInfo){this->m_Error = string( errorInfo);}virtual ~MyOutOfRange(){}virtual const char * what() const{return this->m_Error.c_str() ;}string m_Error;
};
class Person
{
public:Person(int age){if (age <= 0 || age > 150){//抛出异常 越界//cout << "越界" << endl;//throw out_of_range("年龄必须在 0~150 之间");//throw length_error("长度异常");throw MyOutOfRange(("我的异常 年龄必须在 0~150 之间"));}else{this->m_Age = age;}}int m_Age;
};
void test01()
{try{Person p(151);}catch ( out_of_range & e ){cout << e.what() << endl;}catch (length_error & e){cout << e.what() << endl;}catch (MyOutOfRange e){cout << e.what() << endl;}
}