（windows编程 学习笔记一） 结构化异常处理(结束处理)

    本文使用vc编译程序的方法，其他编译器可能不同，但是概念都是一样的。

    使用__try和finally关键字来标出两段代码，操作系统和编译程序共同来确保无论保护体(try块)的代码是如何退出的，结束处理程序(finally块)都会被执行。

    例1

int function()
{
    char *buff = NULL;
    __try
    {
 	printf("malloc memory\n");
        buff = (char*)malloc(10);    //被调用 
    }
    __finally
    {
    	printf("free memory\n");
    	free(buff);                  //被调用
    }
    return 1;
}

int main(int argc, char *argv[])
{
    int ret = function();
    printf("ret = %d\n", ret);       //ret = 1
}

    上面例子代码依次被执行，使用结构化异常没有带来更多好处

    例2

int function()
{
    char *buff = NULL;
    __try
    {
        printf("malloc memory\n");  //被调用
        buff = (char*)malloc(10);
        return 0;                   //先执行finally中的代码，再return
    }
    __finally
    {
        printf("free memory\n");    //被调用
        free(buff);
    }
    return 1;                       //不会被调用
}

int main(int argc, char *argv[])
{
    int ret = function();
    printf("ret = %d\n", ret);  //ret = 0
}

    try块末尾增加了return语句，正常情况下，函数应该直接返回，申请的内存不会被释放，造成内存溢出。通过使用结束处理程序，可以避免return语句过早执行，当return语句试图退出try块是，编译程序要确保finally块中的代码手写被执行。在finally块执行结束之后，函数实际上就返回，finally块之后的代码不会被执行。
    本例防止try块过早return，保证申请内存会被正常释放。但是在try块中过早退出，为了保证finally中的代码被执行，编译器需要生成额外的代码，导致效率降低。

    例3

int function()
{
    char *buff = NULL;
    __try
    {
        printf("malloc memory\n");  
        buff = (char*)malloc(10);
        goto end;                   //先执行finaly中的代码，在执行goto
    }
    __finally
    {
        printf("free memory\n");  
        free(buff);
    }
    return 0;                       //不会被调用
end:
    return 1;                       
}

int main(int argc, char *argv[])
{
    int ret = function();
    printf("ret = %d\n", ret);  //ret = 1
}

    跳转和return一样，保证try执行结束后，finally块中的代码会被执行，由于try中断了到finally块的自然流程，编译器产生了额外的代码，降低了效率。

    例4

int function()
{
    int temp = 0;
    while(temp<10)
    {
        __try
        {
            if(temp == 2)
                continue;
            if(temp == 3)
                break;
        }
        __finally
        { 
            temp++;
        }
        temp++;
    }
    temp+=10;
    return temp;
}

int main(int argc, char *argv[])
{
    int ret = function();
    printf("ret = %d\n", ret);  //ret = 14
}

    程序首先将temp初始化为0，进入循环，try块代码被执行，两个if语言都不为真，代码自然执行到finally块，temp值加1，然后finally之后的代码被执行，temp的值加1，此时temp的值为2。

    第二次循环，第一个if判断的值为真，执行continue语句，在try块退出之前，finally中的代码被执行,temp的值加1，但finally之后的代码会被执行，此时temp的值是3。如果代码中没有结束处理程序，这个循环将会成为一个死循环!

    第三次循环，第二个if语句的值为真，执行break语句，在跳出之前，finally中的代码被执行，temp的值加1，循环结束，执行temp+=10;此时temp的值是14.

    例5

int function()
{
    char *buff = NULL;
    __try
    {
        printf("malloc memory\n");  //被调用
        buff = (char*)malloc(10);
        return 0;
    }
    __finally
    {
        printf("free memory\n");    //被调用
        free(buff);
        return 1;                  
    }
}

int main(int argc, char *argv[])
{
    int ret = function();
    printf("ret = %d\n", ret);  //ret = 1
}

    如果tyr块和finally块都包含return,其中return的值会覆盖try块中return的值。

    例6

int function()
{
    char *buff = NULL;
    FILE *fp = NULL;
    __try
    {
        buff = (char*)malloc(10);
        if(buff == NULL)
	{
            return 0;
	}
	memcpy(buff,"123456789",10);
	fp = fopen("c:\\test.txt","a");
	if(fp == NULL)
	{
	    return 0;
	}
	fwrite(buff,strlen(buff),1,fp);
	fclose(fp);
		
    }
    __finally
    {
        if(buff != NULL)
            free(buff);
        if(fp != NULL)
            fclose(fp);
    }                  
    return 1;
}

int main(int argc, char *argv[])
{
    int ret = function();
    printf("ret = %d\n", ret);  
}

    本例所有清理工作都在集中在finally块中，如果需要再这个函数中在增加条件代码，只需要在finally块中简单的增加一个清理就行，不需要回到每个可能失败的地方都添加清理代码，但是这样做会增加系统开销。

    例7

nt function()
{
    char *buff = NULL;
    FILE *fp = NULL;
    int callResult = 0;
    __try
    {
        buff = (char*)malloc(10);
	if(buff == NULL)
	{
            __leave;
	}
	memcpy(buff,"123456789",10);
	fp = fopen("c:\\test.txt","a");
	if(fp == NULL)
	{
            __leave;
	}
	fwrite(buff,strlen(buff),1,fp);
	fclose(fp);
	callResult = 1;
		
    }
    __finally
    {
        if(buff != NULL)
            free(buff);
        if(fp != NULL)
            fclose(fp);
    }                  
    return callResult;
}

int main(int argc, char *argv[])
{
    int ret = function();
    printf("ret = %d\n", ret);  
}

    为了避免在try中使用return语句，微软在c/c++编译程序中增加了__leave关键字，在try块中使用leave关机字会引起跳转到try块的结尾，由于控制楼自然的从try块进入到finally块，所以不产生系统开销。本例引入新的变量callResult，用来指示函数调用成功还是失败。

    当按照这种方式利用结束程序来设计函数时，要记住在进入try块之前，要将所有资源具备都初始化为无效值，然后在finally块中查看哪些资源被成功分配，就可以指定哪些要释放。另外一种确定要释放资源的办法是对成功分配资源设置一个标志，然后在finally块中可以检测标志的状态，来确定资源释放需要释放。

    我们已经区别了强制执行finally块的两种情况：

    1.从try块进入finally块的自然流程。

    2.从try块的过早退出(return goto break等)强制控制转移到finally块（局部展开）

    还有一种情况：

    3.在发生的时候没有明显的标识，如果try块中的操作引起一个内存访问违规，finally块会执行(全局展开)

    由于以上三种情况中某一种二导致finally块中的代码开始执行。为了确定是哪一种情况引起的finally块执行，可以调用内部函数

    BOOL AbnormalTermination();

    这个函数只能在finally块中调用，指出与finally块相结合的try块是否过早退出。如果控制流离开try块并自然进入到finally块，AbnormaoTermination将返回FALSE,否则会返回TRUE(无法判断是局部展开还是全局展开)。

    最后总结使用结束处理的理由：

    1.简化错误处理，因所有的清理工作都在一个位置并且保证执行。

    2.提高程序的可读性。

    3.使代码更容易维护。

    4.如果使用得当，具有最小的系统开销。