Tente-exceto instrução

Específicos do Microsoft

A sintaxe a seguir descreve um bloco try-exceto a instrução:

__try 
{
   // guarded code
}
__except ( expression )
{
   // exception handler code
}

Comentários

O tente-exceto instrução é uma extensão do Microsoft C e linguagens de C++ que permite que aplicativos de destino para obter controlam quando ocorrem eventos que normalmente termina a execução do programa.Tais eventos são chamados de exceções e o mecanismo que lida com exceções é chamado de manipulação de exceção estruturada.

Para obter informações relacionadas, consulte o try-finally instrução.

Exceções podem ser baseadas em hardware ou software.Mesmo quando os aplicativos não é possível recuperar completamente as exceções de hardware ou software, manipulação de exceção estruturada torna possível exibir informações de erro e o estado interno do aplicativo para ajudar a diagnosticar o problema de trapping.Isso é especialmente útil para problemas intermitentes que não podem ser reproduzidos com facilidade.

Observação
Funciona com o Win32 o tratamento de arquivos de origem de c e C++ de exceção estruturada.No entanto, ele não é especificamente projetado para C++.Você pode garantir que seu código seja mais portátil usando o tratamento de exceções do C++.Além disso, o tratamento de exceção do C++ é mais flexível, que pode lidar com exceções de qualquer tipo.Para programas em C++, é recomendável que você use o mecanismo de tratamento de exceção do C++ (tente, catch e lançar instruções).

Funciona com o Win32 o tratamento de arquivos de origem de c e C++ de exceção estruturada.No entanto, ele não é especificamente projetado para C++.Você pode garantir que seu código seja mais portátil usando o tratamento de exceções do C++.Além disso, o tratamento de exceção do C++ é mais flexível, que pode lidar com exceções de qualquer tipo.Para programas em C++, é recomendável que você use o mecanismo de tratamento de exceção do C++ (tente, catch e lançar instruções).

A instrução composta após o __try cláusula é o corpo ou a seção protegida.A instrução composta após o __except cláusula é o manipulador de exceção.O manipulador Especifica um conjunto de ações a serem tomadas se uma exceção é gerada durante a execução do corpo da seção protegido.Execução ocorre da seguinte maneira:

A seção protegida é executada.
Se nenhuma exceção ocorrer durante a execução da seção protegida, a execução continua com a instrução após a __except cláusula.
Se ocorre uma exceção durante a execução da seção protegida ou em qualquer rotina a seção protegida chama, o __exceptexpressão (chamado de filtro expressão) é avaliada e o valor que determina como a exceção é tratada. Existem três valores:

EXCEPTION_CONTINUE_EXECUTION (– 1) exceção é descartada.Continue a execução no ponto onde a exceção ocorreu.

EXCEPTION_CONTINUE_SEARCH (0) exceção não é reconhecida.Continuar a procurar na pilha de um manipulador, primeiro contendo tente-exceto instruções, em seguida, para manipuladores com a próxima maior precedência.

EXCEPTION_EXECUTE_HANDLER (1) exceção é reconhecida.Transferir o controle para o manipulador de exceção, executando o __except instrução composta, em seguida, continuar a execução após a __except bloco.

Porque o _ _, exceto expressão é avaliada como uma expressão C, é limitado a um único valor, o operador condicional-expressão ou o operador de vírgula.Se for necessário o processamento mais abrangente, a expressão pode chamar uma rotina que retorna um dos três valores listados acima.

Cada aplicativo pode ter seu próprio manipulador de exceção.

Não é válido para saltar para uma __try declaração, mas válido para saltar para fora de um.O manipulador de exceção não é chamado, se um processo é finalizado no meio da execução de um tente-exceto instrução.

Para obter mais informações, consulte o artigo Q315937 do Knowledge Base: HOW TO: interceptação de estouro de pilha em um aplicativo Visual C++.

A palavra-chave de __leave

O __leave palavra-chave só é válido dentro da seção protegida de um try-except é a instrução e seu efeito saltar para o final da seção protegido.A execução continua na primeira instrução após o manipulador de exceção.

A goto declaração também pode saltar da seção protegida e ele não prejudica o desempenho como acontece em um try-finally instrução porque o desenrolamento de pilha não ocorrerá.No entanto, recomendamos que você use o __leave palavra-chave em vez de um goto instrução porque você terá menos probabilidade de cometer um erro de programação, se a seção protegida for grande ou complexo.

Funções intrínsecas de manipulação de exceção de estruturada

Manipulação de exceção estruturada fornece duas funções intrínsecas que estão disponíveis para uso com o tente-exceto instrução: GetExceptionCode e GetExceptionInformation.

GetExceptionCode retorna o código (um inteiro de 32 bits) da exceção.

A função intrínseca GetExceptionInformation retorna um ponteiro para uma estrutura que contém informações adicionais sobre a exceção.Esse ponteiro, você pode acessar o estado da máquina que existiam no momento de uma exceção de hardware.A estrutura é como segue:

struct _EXCEPTION_POINTERS {
      EXCEPTION_RECORD *ExceptionRecord,
      CONTEXT *ContextRecord }

O ponteiro tipos _EXCEPTION_RECORD e _contexto são definidos no arquivo de inclusão EXCPT.H.

Você pode usar GetExceptionCode dentro do manipulador de exceção.Entretanto, você pode usar GetExceptionInformation somente dentro da expressão de filtro de exceção.As informações que ele aponta é geralmente na pilha e não está mais disponíveis quando o controle é transferido para o manipulador de exceção.

A função intrínseca AbnormalTermination está disponível dentro de um manipulador de terminação.Retorna 0 se o corpo da try-finally instrução finaliza seqüencialmente.Em outros casos, ele retornará 1.

EXCPT.H define alguns nomes alternativos para esses elementos intrínsecos do:

GetExceptionCode é equivalente a _exception_code

GetExceptionInformation é equivalente a _exception_info

AbnormalTermination é equivalente a _abnormal_termination

Exemplo

// exceptions_try_except_Statement.cpp

// Example of try-except and try-finally statements

#include <stdio.h>

#include <windows.h> // for EXCEPTION_ACCESS_VIOLATION

#include <excpt.h>

int filter(unsigned int code, struct _EXCEPTION_POINTERS *ep) {

puts("in filter.");

if (code == EXCEPTION_ACCESS_VIOLATION) {

puts("caught AV as expected.");

return EXCEPTION_EXECUTE_HANDLER;

}

else {

puts("didn't catch AV, unexpected.");

return EXCEPTION_CONTINUE_SEARCH;

};

}

int main()

{

int* p = 0x00000000; // pointer to NULL

puts("hello");

__try{

puts("in try");

__try{

puts("in try");

*p = 13; // causes an access violation exception;

}__finally{

puts("in finally. termination: ");

puts(AbnormalTermination() ? " \tabnormal" : "\tnormal");

}

}__except(filter(GetExceptionCode(), GetExceptionInformation())){

puts("in except");

}

puts("world");

}

Saída

hello
in try
in try
in filter.
caught AV as expected.
in finally. termination:
        abnormal
in except
world

Específicos do Microsoft final

Consulte também

Referência

Escrever um manipulador de exceção

(C++) de manipulação de exceção estruturada

Palavras-chave C++

Last updated on 2013-02-25