syntaxe Termination-Handler

Les mots clés __try et __finally sont utilisés pour construire un gestionnaire de terminaison. L’exemple suivant montre la structure d’un gestionnaire de terminaison.

__try 
{ 
    // guarded body of code 
 
} 
__finally 
{ 
    // __finally block 
 
}

Pour obtenir des exemples, consultez Utilisation d’un gestionnaire de terminaison.

Comme pour le gestionnaire d’exceptions, le bloc __try et le bloc __finally nécessitent des accolades ({}), et l’utilisation d’une instruction goto pour accéder à un bloc n’est pas autorisée.

Le bloc __try contient le corps protégé du code protégé par le gestionnaire d’arrêt. Une fonction peut avoir n’importe quel nombre de gestionnaires de terminaison, et ces blocs de gestion des terminaisons peuvent être imbriqués dans la même fonction ou dans différentes fonctions.

Le bloc __finally est exécuté chaque fois que le flux de contrôle quitte le bloc __try . Toutefois, le bloc __finally n’est pas exécuté si vous appelez l’une des fonctions suivantes dans le bloc __try : ExitProcess, ExitThread ou abandon.

Le bloc __finally est exécuté dans le contexte de la fonction dans laquelle se trouve le gestionnaire de terminaison. Cela signifie que le bloc __finally peut accéder aux variables locales de cette fonction. L’exécution du bloc __finally peut se terminer par l’un des moyens suivants.

• Exécution de la dernière instruction dans le bloc et la continuation vers l’instruction suivante
• Utilisation d’une instruction de contrôle (return, break, continue ou goto)
• Utilisation de longjmp ou d’un saut vers un gestionnaire d’exceptions

Si l’exécution du bloc __try se termine en raison d’une exception qui appelle le bloc de gestion des exceptions d’un gestionnaire d’exceptions basé sur une trame, le bloc __finally est exécuté avant l’exécution du bloc de gestion des exceptions. De même, un appel à la fonction de bibliothèque d’exécution C longjmp à partir du bloc __try provoque l’exécution du bloc __finally avant que l’exécution ne reprend à la cible de l’opération longjmp . Si __try exécution de bloc se termine en raison d’une instruction de contrôle (return, break, continue ou goto), le bloc __finally est exécuté.

La fonction AbnormalTermination peut être utilisée dans le bloc __finally pour déterminer si le bloc __try s’est arrêté séquentiellement , autrement dit, s’il a atteint l’accolades fermante (}). Laissant le bloc __try en raison d’un appel à longjmp, un saut vers un gestionnaire d’exceptions ou un retour, un saut, un arrêt, une poursuite ou une instruction goto , est considéré comme un arrêt anormal. Notez que l’échec de la fin séquentielle entraîne l’appel de tous les cadres de pile dans l’ordre inverse pour déterminer si les gestionnaires d’arrêt doivent être appelés. Cela peut entraîner une dégradation des performances en raison de l’exécution de centaines d’instructions.

Pour éviter l’arrêt anormal du gestionnaire de terminaison, l’exécution doit continuer à la fin du bloc. Vous pouvez également exécuter l’instruction __leave . L’instruction __leave autorise l’arrêt immédiat du bloc __try sans entraîner une interruption anormale et sa pénalité de performance. Vérifiez la documentation de votre compilateur pour déterminer si l’instruction __leave est prise en charge.

Si l’exécution du bloc __finally se termine en raison de l’instruction de contrôle de retour , elle équivaut à un goto à l’accolades fermante dans la fonction englobante. Par conséquent, la fonction englobante retourne.