C++ 中的异常抛出和捕获方式

在 C 语言中，如果发生错误，上级函数要进行出错处理，层层上传，容易造成过多的出错处理代码，并且传递的效率比较低下。

C++ 中的异常

C++ 中，异常的引发和异常的处理不必处于同一个函数中，因此底层函数可以着重于解决具体问题，而不必过多的考虑异常处理

异常是专门针对抽象编程中的一系列错误处理的，遇到错误信息就转到若干级之上进行重新尝试

异常脱离于函数机制，决定了其对函数的跨越式回跳

语法

try
{
? ? statement;
}
catch(ExceptionType var)
{
? ? statement;
}

被检测的语句放在 try 块中

try catch 语句中的花括号是语法的一部分，不能省略

try-catch 结构中，只能有一个 try 块，catch 块可以有多个，以便与不同的类型信息匹配，有点类似于 switch-case 结构

利用 throw 抛出的异常类型，可以传递系统预定义的标准类型或自定义类型

从 throw 抛出异常，到 catch 捕获异常，有点类似与利用函数的返回值进行复制一样，因此如果使用了自定义类型，需要考虑自定义类型的赋值和拷贝问题

如果 catch 语句没有与之相匹配的异常类型信息，可以用(...)表示可以捕获任何异常类型的信息，有点类似与 switch-case 结构中的 default

try-catch 结构可以与 throw 在同一函数中，也可以不在同一个函数中，throw 抛出异常后，会先在本函数中寻找与之相匹配的 catch 块，如果没有与之相匹配的 catch，就可以转到上一层 try-catch，如果仍然没有

匹配到，则转到再上一层 try-catch...，如果最终到不到与之匹配的 try-catch 块，系统就会调用系统函数，terminal 使程序终止

#include <iostream>
?
using namespace std;
?
void func1()
{
? ? double a;
? ? try{
? ? ? ? throw a;
? ? }catch(double)
? ? {
? ? ? ? cout<<"catch func1()"<<endl; //throw
? ? }
? ? cout<<"end func1()"<<endl;
? ? return ;
}
?
void func2()
{
? ? try{
? ? ? ? func1();
? ? }catch(int)
? ? {
? ? ? ? cout<<"catch func2()"<<endl;
? ? }
? ? cout<<"end func2()"<<endl;
}
?
void func3()
{
? ? try{
? ? ? ? func2();
? ? }catch(char)
? ? {
? ? ? ? cout<<"catch func3()"<<endl;
? ? }
? ? cout<<"end func3()"<<endl;
}
?
int main()
{
? ? try{
? ? ? ? func3();
? ? }catch(double)
? ? {
? ? ? ? cout<<"catch main"<<endl;
? ? }
? ? cout<<"end main"<<endl;
? ? return 0;
}

结果为：

catch func1()
end func1()
end func2()
end func3()
end main

上边的异常传递路线为 func3->func2()->func1()，在 func1 中找到对应的 catch 块，然后执行对应 catch 块中的语句，输出：

catch func1()

整个的异常处理已经结束，跳出 func1() 的 try-catch 块，继续执行 func1() 的函数体，陆续输出:

end func1()
end func2()
end func3()
end main

此时进程结束。

如果将 func1() 中的 catch 到的异常类型换个类型，如：

catch(void *)

结果为：

catch main
end main

则会在 func1()，func2()，func3() 中都找不到对应的 catch 匹配，直到 main 函数才能找到对应的匹配，然后输出：

catch main
end main

如果将 main 函数中的 catch 捕获类型也修改为：

catch(void *)

结果为：

terminate called after throwing an instance of 'double'
 
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.

此时系统就会调用系统函数，使程序终止。

抛出类型声明

为了增强程序的可读性，可以在函数声明时就列出所有可能抛出的异常类型

void func() throw (A,B,C); ? ? // 表明该函数只会抛出 A,B,C 及其子类型的异常

如果在函数声明时没有声明可能抛出的异常类型，则函数可以抛出任意类型的异常

不抛出任何类型异常的函数，可以声明为：

void func() throw();

如果一个函数抛出了抛出类型声明中所不允许的异常，unexpected 函数被调用，启用 terminal 函数中止程序

栈自旋

异常被抛出后，从进入 try 块起，到异常被抛掷前，这期间在栈上的构造的所有对象，都会被自动析构

析构的顺序与构造的顺序相反。这一过程称为栈的解旋

而堆上的空间，则会泄漏

#include <iostream>
?
using namespace std;
?
class A
{
public:
? ? A(){ cout<<"A()"<<endl; }
? ? ~A(){ cout<<"~A()"<<endl; }
};
?
int func1()
{
? ? A a;
? ? if(1)
? ? ? ? throw('a');
? ? return 0;
}
?
int func2()
{
? ? A b;
? ? func1();
? ? return 1;
}
?
int main()
{
? ? try{
? ? ? ? func2();
? ? }catch(int x){
? ? ? ? cout<<"x"<<endl;
? ? }catch(double y){
? ? ? ? cout<<"y"<<endl;
? ? }catch(...){
? ? ? ? cout<<"no x, no y"<<endl;
? ? }
? ? return 0;
}

结果为：

A()
A()
~A()
~A()
no x, no y

如果 throw 的是一个类对象：

#include <iostream>
?
using namespace std;
?
class A
{
public:
? ? A(){ cout<<"A()"<<endl; }
? ? A(const A &obj){ cout<<"A(const A &obj)"<<endl; }
? ? ~A(){ cout<<"~A()"<<endl; }
};
?
int func1()
{
? ? A a;
? ? if(1)
? ? ? ? throw(a);
? ? return 0;
}
?
int func2()
{
? ? func1();
? ? return 1;
}
?
int main()
{
? ? try{
? ? ? ? func2();
? ? }catch(int x){
? ? ? ? cout<<"x"<<endl;
? ? }catch(double y){
? ? ? ? cout<<"y"<<endl;
? ? }catch(const A &a){
? ? ? ? cout<<"no x, no y"<<endl;
? ? }
? ? return 0;
}

结果为：

A()
A(const A &obj)
~A()
no x, no y
~A()

来源：https://blog.csdn.net/SAKURASANN/article/details/105983755