__try __except與__try __finally的嵌套使用以及__finally的調用時機

原文：https://blog.csdn.net/SwordArcher/article/details/82465522 

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 <iostream>
#include <Windows.h> 
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