Compartilhar via

Tratamento estruturado de exceções (C/C++)

O SEH (tratamento estruturado de exceções) é uma extensão da Microsoft para C e C++ para lidar com determinadas situações de código excepcionais, como falhas de hardware, normalmente. Embora o Windows e o Microsoft C++ ofereçam suporte ao SEH, recomendamos que você use o tratamento de exceção C++ padrão ISO no código C++. Isso torna seu código mais portátil e flexível. No entanto, para manter o código existente ou para determinados tipos de programas, talvez você ainda precise usar SEH.

Específico da Microsoft:

Gramática

try-except-statement :
  __try compound-statement __except ( filter-expression ) compound-statement

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

Observações

Com o SEH, você pode garantir que os recursos, como blocos de memória e arquivos, sejam liberados corretamente se a execução for encerrada inesperadamente. Você também pode lidar com problemas específicos, por exemplo, memória insuficiente, usando código estruturado conciso que não depende goto de instruções ou teste elaborado de códigos de retorno.

As try-except instruções mencionadas try-finally neste artigo são extensões da Microsoft para as linguagens C e C++. Eles dão suporte ao SEH, permitindo que os aplicativos obtenham o controle de um programa após eventos que, de outra forma, encerrariam a execução. Embora o SEH funcione com arquivos de origem C++, ele não foi projetado especificamente para C++. Se você usar SEH em um programa C++ compilado usando a opção ou /EHsca opção/EHa, destruidores para objetos locais serão chamados, mas outro comportamento de execução pode não ser o esperado. Para obter uma ilustração, consulte o exemplo mais adiante neste artigo. Na maioria dos casos, em vez de SEH, recomendamos que você use o tratamento de exceção C++ padrão ISO. Usando o tratamento de exceções do C++, você pode garantir que seu código seja mais portátil e que você possa lidar com exceções de qualquer tipo.

Se você tiver um código C que usa SEH, você poderá misturá-lo com o código C++ que usa o tratamento de exceção C++. Para obter informações, consulte Manipular exceções estruturadas no C++.

Há dois mecanismos SEH:

Esses dois tipos de manipuladores são distintos, mas estão intimamente relacionados por meio de um processo conhecido como desenrolamento da pilha. Quando ocorre uma exceção estruturada, o Windows procura o manipulador de exceção instalado mais recentemente que está ativo no momento. O manipulador pode fazer uma das três coisas:

  • Falha ao reconhecer a exceção e passar o controle para outros manipuladores (EXCEPTION_CONTINUE_SEARCH).

  • Reconhecer a exceção, mas descartá-la (EXCEPTION_CONTINUE_EXECUTION).

  • Reconheça a exceção e manipule-a (EXCEPTION_EXECUTE_HANDLER).

O manipulador de exceção que reconhece a exceção pode não estar na função em execução quando a exceção ocorreu. Ele pode estar em uma função muito mais alta na pilha. A função em execução no momento e todas as outras funções no quadro de pilha são encerradas. Durante esse processo, a pilha é desfeito. Ou seja, variáveis não estáticas locais de funções terminadas são desmarcadas da pilha.

À medida que desenrola a pilha, o sistema operacional chama todos os manipuladores de terminação que você escreveu para cada função. Usando um manipulador de terminação, você limpa os recursos que, de outra forma, permaneceriam abertos devido a uma terminação anormal. Se você inseriu uma seção crítica, poderá sair dela no manipulador de terminação. Quando o programa for desligado, você poderá realizar outras tarefas de limpeza, como fechar e remover arquivos temporários.

Próximas etapas

Exemplo

Conforme indicado anteriormente, os destruidores para objetos locais serão chamados se você usar SEH em um programa C++ e compilá-lo usando a opção ou /EHsc a opção/EHa. No entanto, o comportamento durante a execução pode não ser o esperado se você também estiver usando exceções C++. Este exemplo demonstra essas diferenças comportamentais.

#include <stdio.h>
#include <Windows.h>
#include <exception>

class TestClass
{
public:
    ~TestClass()
    {
        printf("Destroying TestClass!\n");
    }
};

__declspec(noinline) void TestCPPEX()
{
#ifdef CPPEX
    printf("Throwing C++ exception\n");
    throw std::exception("");
#else
    printf("Triggering SEH exception\n");
    volatile int *pInt = 0x00000000;
    *pInt = 20;
#endif
}

__declspec(noinline) void TestExceptions()
{
    TestClass d;
    TestCPPEX();
}

int main()
{
    __try
    {
        TestExceptions();
    }
    __except(EXCEPTION_EXECUTE_HANDLER)
    {
        printf("Executing SEH __except block\n");
    }

    return 0;
}

Se você usar /EHsc para compilar esse código, mas a macro CPPEX de controle de teste local for indefinida, o TestClass destruidor não será executado. A saída tem esta aparência:

Triggering SEH exception
Executing SEH __except block

Se você usar /EHsc para compilar o código e CPPEX for definido usando /DCPPEX (para que uma exceção C++ seja gerada), o TestClass destruidor será executado e a saída terá esta aparência:

Throwing C++ exception
Destroying TestClass!
Executing SEH __except block

Se você usar /EHa para compilar o código, o TestClass destruidor executará se uma exceção foi lançada usando uma expressão C++ throw padrão ou usando SEH. Ou seja, se CPPEX está definido ou não. A saída tem esta aparência:

Throwing C++ exception
Destroying TestClass!
Executing SEH __except block

Para obter mais informações, consulte /EH (Modelo de Tratamento de Exceções).

END específico da Microsoft

Consulte também

Manuseio de exceção
Palavras-chave
<exception>
Erros e tratamento de exceções
Tratamento estruturado de exceções (Windows)

  • Last updated on