当前位置: 首页>前端>正文

axios get 嵌套对象 嵌套try

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


https://www.xamrdz.com/web/2mu1957648.html

相关文章: