declaración try-finally

La try-finally instrucción es una extensión específica de Microsoft que admite el control estructurado de excepciones en los lenguajes C y C++.

Sintaxis

La siguiente sintaxis describe la try-finally instrucción :

    // . . .
    __try {
        // guarded code
    }
    __finally {
        // termination code
    }
    // . . .

Gramática

try-finally-statement:
  __try compound-statement __finally compound-statement

La try-finally instrucción es una extensión de Microsoft para los lenguajes C y C++ que permiten a las aplicaciones de destino garantizar la ejecución del código de limpieza cuando se interrumpe la ejecución de un bloque de código. La limpieza consta de tareas como desasignar memoria, cerrar archivos y liberar identificadores de archivo. La try-finally instrucción es especialmente útil para las rutinas que tienen varios lugares donde se realiza una comprobación para un error que podría provocar un retorno prematuro de la rutina.

Para obtener información relacionada y un ejemplo de código, vea try-except Instrucción . Para obtener más información sobre el control de excepciones estructurado en general, vea Control de excepciones estructurados. Para obtener más información sobre el control de excepciones en aplicaciones administradas con C++/CLI, consulte Control de excepciones en /clr.

Nota:

El control de excepciones estructurado funciona con Win32 para archivos de código fuente de C y C++. Sin embargo, no está diseñado específicamente para C++. Puede asegurarse de que el código sea más portátil mediante el control de excepciones de C++. Además, el control de excepciones de C++ es más flexible, ya que puede controlar excepciones de cualquier tipo. En el caso de los programas de C++, se recomienda usar el mecanismo de control de excepciones de C++ (try, catchy throw instrucciones ).

La instrucción compuesta después de la __try cláusula es la sección protegida. La instrucción compuesta después de la __finally cláusula es el controlador de terminación. El controlador especifica un conjunto de acciones que se ejecutan cuando se sale de la sección protegida, ya sea que salga de la sección protegida por una excepción (terminación anómala) o por caída estándar (terminación normal).

El control alcanza una instrucción mediante una __try ejecución secuencial simple (cae a través). Cuando el control entra en __try, su controlador asociado se activa. Si el flujo de control alcanza el final del bloque try, la ejecución continúa de la siguiente manera:

1. Se invoca el controlador de terminación.

2. Cuando se completa el controlador de terminación, la ejecución continúa después de la __finally instrucción . Sin embargo, la sección protegida finaliza (por ejemplo, a través de un goto fuera del cuerpo protegido o una return instrucción ), el controlador de terminación se ejecuta antes de que el flujo de control salga de la sección protegida.

   Una __finally instrucción no bloquea la búsqueda de un controlador de excepciones adecuado.

Si se produce una excepción en el __try bloque , el sistema operativo debe encontrar un controlador para la excepción o se producirá un error en el programa. Si se encuentra un controlador, todos y todos los __finally bloques se ejecutan y la ejecución se reanuda en el controlador.

Por ejemplo, supongamos que una serie de llamadas de función vinculan la función A a la función D, como se muestra en la ilustración siguiente. Cada función tiene un controlador de terminación. Si se produce una excepción en la función D y se controla en A, se llama a los controladores de terminación en este orden a medida que el sistema desenreda la pila: D, C, B.

El diagrama comienza con la función A, que llama a la función B, que llama a la función C, que llama a la función D. La función D genera una excepción. A continuación, se llama a los controladores de terminación en este orden: controlador de terminación D, luego C, B y, a continuación, A controla la excepción.

Orden de ejecución del controlador de terminación

Nota:

El comportamiento de try-finally es diferente de otros lenguajes que admiten el uso de finally, como C#. Un solo __try puede tener, pero no ambos, de __finally y __except. Si ambos se van a usar juntos, una instrucción try-except externa debe incluir la instrucción try-finally interna. Las reglas que especifican cuándo se ejecuta cada bloque también son diferentes.

Para la compatibilidad con versiones anteriores, _try, _finallyy _leave son sinónimos de __try, __finallyy __leave a menos que se especifique la opción /Za del compilador (Deshabilitar extensiones de lenguaje).

Palabra clave __leave

La __leave palabra clave solo es válida dentro de la sección protegida de una try-finally instrucción y su efecto es saltar al final de la sección protegida. La ejecución continúa en la primera instrucción del controlador de terminación.

Una goto instrucción también puede saltar de la sección protegida, pero degrada el rendimiento porque invoca el desenredado de la pila. La __leave instrucción es más eficaz porque no provoca el desenredado de la pila.

Terminación anómala

La salida de una try-finally instrucción mediante la función longjmp en tiempo de ejecución se considera una terminación anómala. No es legal saltar a una __try declaración, pero es legal salir de uno. Se deben ejecutar todas las __finally instrucciones que están activas entre el punto de salida (terminación normal del __try bloque) y el destino (el __except bloque que controla la excepción). Se denomina desenredado local.

Si un __try bloque finaliza prematuramente por cualquier motivo, incluido un salto fuera del bloque, el sistema ejecuta el bloque asociado __finally como parte del proceso de desenredado de la pila. En tales casos, la AbnormalTermination función devuelve true si se llama desde dentro del __finally bloque; de lo contrario, devuelve false.

No se llama al controlador de terminación si se elimina un proceso en medio de la ejecución de una try-finally instrucción .

END específico de Microsoft

Consulte también

Escritura de un controlador de terminación
Control estructurado de excepciones (C/C++)
Palabras clave
Sintaxis del controlador de terminación