Termination-Handler Sintaxe

As palavras-chave __try e __finally são usadas para construir um manipulador de terminação. O exemplo a seguir mostra a estrutura de um manipulador de terminação.

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

Para obter exemplos, consulte Usando um manipulador de terminação.

Tal como acontece com o manipulador de exceção, tanto o bloco __try como o bloco __finally requerem chaves ({}), e o uso de uma instrução goto para saltar para qualquer um dos blocos não é permitido.

O bloco __try contém o corpo de código protegido que é protegido pelo manipulador de terminação. Uma função pode ter qualquer número de manipuladores de terminação, e esses blocos de tratamento de terminação podem ser aninhados dentro da mesma função ou em funções diferentes.

O bloco __finally é executado sempre que o fluxo de controle sai do bloco __try. No entanto, o bloco __finally não é executado se você chamar qualquer uma das seguintes funções dentro do bloco __try: ExitProcess, ExitThreadou abortar.

O bloco __finally é executado no contexto da função na qual o manipulador de terminação está localizado. Isso significa que o bloco __finally pode acessar as variáveis locais dessa função. A execução do __finally bloco pode terminar por qualquer um dos seguintes meios.

• Execução da última instrução no bloco e continuação para a próxima instrução
• Uso de uma instrução de controle (retorno, quebra, continuarou goto)
• Uso de longjmp ou um salto para um manipulador de exceções

Se a execução do bloco __try for encerrada devido a uma exceção que invoque o bloco de tratamento de exceções de um manipulador de exceções baseado em quadros, o bloco de __finally será executado antes que o bloco de tratamento de exceções seja executado. Da mesma forma, uma chamada para a função de biblioteca de tempo de execução longjmp C do bloco __try causa a execução do bloco __finally antes que a execução seja retomada no destino da operação longjmp. Se __try execução do bloco for encerrada devido a uma instrução de controle (return, break, continueou goto), o bloco __finally será executado.

A função AbnormalTermination pode ser usada dentro do bloco __finally para determinar se o bloco __try terminou sequencialmente — ou seja, se atingiu a chave de fechamento (}). Deixar o bloco de __try por causa de uma chamada para longjmp, um salto para um manipulador de exceções ou um de retorno, quebrar, continuarou instrução goto, é considerado uma rescisão anormal. Observe que a falha ao encerrar sequencialmente faz com que o sistema pesquise todos os quadros de pilha na ordem inversa para determinar se algum manipulador de terminação deve ser chamado. Isso pode resultar em degradação do desempenho devido à execução de centenas de instruções.

Para evitar a rescisão anormal do manipulador de terminação, a execução deve continuar até o final do bloco. Você também pode executar a instrução __leave. A declaração de __leave permite a rescisão imediata do bloco de __try sem causar rescisão anormal e sua penalidade de desempenho. Verifique a documentação do compilador para determinar se a instrução __leave é suportada.

Se a execução do bloco de __finally for encerrada devido à instrução return control, ela será equivalente a um goto à chave de fechamento na função de inclusão. Portanto, a função de inclusão retornará.