__try __except与__try __finally的嵌套使用以及__finally的调用时机

__try __except与__try __finally的嵌套使用以及__finally的调用时机

try-finally语句的语法与try-except很类似，稍有不同的是，__finally后面没有一个表达式，这是因为try- finally语句的作用不是用于异常处理，所以它不需要一个表达式来判断当前异常错误的种类。另外，与try-except语句类似，try- finally也可以是多层嵌套的，并且一个函数内可以有多个try-finally语句，不管它是嵌套的，或是平行的。当然，try-finally多层嵌套也可以是跨函数的。一个__try可以对应一个__except或者一个__finally，但是不能有__try  __except  __finally这样的结构，而__try __except和__try __finally俩者可以相互嵌套使用，__finally中的代码，无论是否遇到异常，都会被调用，但它的调用时机会因实际情况而异。

一、__try __finally结构正常运行，顺序执行到__finally(没有异常情况)：

void main()
{
	puts("hello");
	__try
	{
		puts("__try块中");
	}
	__finally
	{
		puts("__finally块中");
	}
	puts("world");
}

打印情况如下： 顺序执行，world在__finally之后正常打印

hello
__try块中
__finally块中
world

二、goto语句或return语句引发的程序控制流离开当前__try块作用域时，系统自动完成对__finally块代码的调用

void main()
{
	__try
	{
		puts("__try块中");
		return;   //return语句直接让函数返回
	}
	__finally
	{
		puts("__finally块中");
	}
	puts("此处不会执行");
}

打印结果为：

__try块中
__finally块中

三、在某个__try块中出现异常时，导致程序控制流离开当前__try块作用域，去寻找对应的__except块，如果对应的__except块不能处理这个异常则继续向上寻找可以处理这个异常的__except块，当找到可以处理异常的__except的时候(异常被识别)，在进入这个__except块作用域之前，调用之前的__finally的代码，然后在执行__except中的代码，如下：

#include "stdafx.h"
#include 
#include  
using namespace std;

void  test()
{
	int *  p = 0x00000000;  //  pointer to NULL 
	__try
	{
		puts(" in try2 ");
		__try
		{
			puts(" in try3 ");			
			* p = 13;  //导致一个存储异常 
			puts(" 这里不会被执行到 ");
		}
		__finally
		{
			puts(" in finally ");
		}
		puts(" 这里也不会被执行到 ");
	}
	__except (puts(" in filter 1 "), EXCEPTION_CONTINUE_SEARCH)  //不在当前except块处理，继续寻找可以处理此异常的except块
	{
		puts(" in except 1 ");  //此块不会被执行，所以不会打印
	}
}

void main()
{
	puts(" hello ");

	__try
	{
		puts(" in try1 ");
		__try
		{
			test();
		}
		__except (puts(" in filter 2 "), EXCEPTION_CONTINUE_SEARCH) //不在当前except块处理，继续寻找可以处理此异常的except块
		{
			puts(" in except 2 ");  //此块不会被执行，所以不会打印
		}
	}
	__except (puts(" in filter 3"), EXCEPTION_EXECUTE_HANDLER)  //异常被识别，可以在此except块中对异常进行处理
	{
		puts(" in except 3 ");
		puts(" world ");
	}
}

打印结果如下图：

hello
in try1
in try2
in try3
in filter 1
in filter 2
in filter 3
in finally
in except 3
world

 

无论是第 2种，还是第3种情况，毫无疑问，它们都会引起很大的系统开销，编译器在编译此类程序代码时，它会为这两种情况准备很多的额外代码。一般第2种情况，被称为“局部展开（LocalUnwinding）”；第3种情况，被称为“全局展开（GlobalUnwinding）， 第3种情况，也即由于出现异常而导致的“全局展开”，对于程序员而言，这也许是无法避免的，因为你在利用异常处理机制提高程序可靠健壮性的同时，不可避免的会引起性能上其它的一些开销但是，对于第2种情况，程序员完全可以有效地避免它，避免“局部展开”引起的不必要的额外开销。实际这也是与结构化程序设计思想相一致的，也即一个程序模块应该只有一个入口和一个出口，程序模块内尽量避免使用goto语句等。但是，话虽如此，有时为了提高程序的可读性，程序员在编写代码时，有时可能不得不采用一些与结构化程序设计思想相悖的做法，例如，在一个函数中，可能有多处的return语句。针对这种情况，SEH提供了一种非常有效的折衷方案，那就是__leave关键字所起的作用，它既具有像goto语句和return语句那样类似的作用（由于检测到某个程序运行中的错误，需要马上离开当前的 __try块作用域），但是又避免了“局部展开” 的额外开销。

void test()
{
	puts("hello");
	__try
	{
		int* p;
		puts("__try块中");
		__leave;   //直接跳出当前的__try作用域
		p = 0;
		*p = 25;
	}
	__finally
	{
		puts("__finally块中");
	}
	puts("world");
}

void main()
{
	__try
	{
		test();
	}
	__except (1)
	{
		puts("__except块中");
	}
}

打印如下：

hello
__try块中
__finally块中
world