_set_se_translator

Artigo
06/09/2015

As exceções do Win32 de identificadores (exceções estruturado de 2.0 C) como C++ digitaram exceções.

_se_translator_function _set_se_translator(
   _se_translator_function seTransFunction
);

Parâmetros

seTransFunction
Ponteiro para a função é estruturada c de tradutor de exceção que você criou.

Valor de retorno

Retorna um ponteiro para a função anterior de tradutor registrada por _set_se_translator, de forma que a função anterior pode ser restaurados posteriormente. Se nenhuma função anterior foi definida, o valor de retorno pode ser usado para restaurar o comportamento padrão; esse valor pode ser NULL.

Comentários

A função de _set_se_translator fornece uma maneira de tratar exceções do Win32 (exceções estruturado de 2.0 C) como exceções digitadas C++. Para permitir que cada um uma exceção C seja tratada pelo manipulador c criando catch , primeiro defina a classe de invólucro de exceção de c que pode ser usado, ou derivada, para atribuir um tipo específico da classe com exceção de c. Para usar essa classe, instale uma função personalizada de tradutor da exceção de 2.0 C que é chamado pela exceção interna c do mecanismo de manipulação de exceções gerais será emitido cada vez. Dentro da função de tradutor, você pode gerar qualquer exceção com tipo que possa ser capturada por um manipulador de correspondência C++ catch .

Você deve usar /EHa ao usar _set_se_translator.

Para especificar uma função personalizada de tradução, chame _set_se_translator com o nome da função de conversão como seu argumento. A função de tradutor que você gravação é chamado uma vez para cada invocação de função na pilha que tem blocos de try . Não há nenhuma função padrão de tradutor.

A função de tradutor deve fazer não mais do que gerou a exceção digitada c. criando Se faz nada além do kit (como gravar um arquivo de log, por exemplo) seu programa não podem se comportar como esperado, como o número de vezes que a função de tradutor é chamada é dependente de plataforma.

Em um ambiente multithread, as funções de tradutor são mantidas separadamente para cada thread. Necessidades de cada thread de instalar novos sua própria função de tradutor. Assim, cada thread é responsável de sua própria manipulação de tradução para o. _set_se_translator é específico a um thread; outro DLL pode instalar uma função diferente da conversão.

A função de seTransFunction que você gravação deve ser uma função compilada nativo (não criada com /clr). Deve ser um número inteiro sem sinal e um ponteiro para uma estrutura do Win32 _EXCEPTION_POINTERS como argumentos. Os argumentos são os valores de retorno de chamadas à API do Win32 GetExceptionCode e funções de GetExceptionInformation , respectivamente.

typedef void (*_se_translator_function)(unsigned int, struct _EXCEPTION_POINTERS* );

Para _set_se_translator, as implicações dinamicamente ao vincular a CRT; outro DLL do processo pode chamar _set_se_translator e substituir o manipulador com seus próprios.

Ao usar _set_se_translator de código gerenciado (código compilado com /clr) ou nativo misto e código gerenciado, lembre-se de que o tradutor afeta as exceções geradas em código nativo. Nenhuma exceções gerenciado gerada no código gerenciado (como aumentar System::Exception) não são roteadas através da função de tradutor. As exceções geradas em código gerenciado usando a função RaiseException do Win32 ou causadas por uma exceção do sistema como uma exceção divisão por zero são roteadas através de tradutor.

Requisitos

Rotina	Cabeçalho necessário
_set_se_translator	<eh.h>

A funcionalidade fornecida por _set_se_translator não está disponível no código compilado com a opção do compilador de /clr: puro .

Para obter mais informações sobre compatibilidade, consulte Compatibilidade na Introdução.

Exemplo

// crt_settrans.cpp
// compile with: /EHa
#include <stdio.h>
#include <windows.h>
#include <eh.h>

void SEFunc();
void trans_func( unsigned int, EXCEPTION_POINTERS* );

class SE_Exception
{
private:
    unsigned int nSE;
public:
    SE_Exception() {}
    SE_Exception( unsigned int n ) : nSE( n ) {}
    ~SE_Exception() {}
    unsigned int getSeNumber() { return nSE; }
};
int main( void )
{
    try
    {
        _set_se_translator( trans_func );
        SEFunc();
    }
    catch( SE_Exception e )
    {
        printf( "Caught a __try exception with SE_Exception.\n" );
    }
}
void SEFunc()
{
    __try
    {
        int x, y=0;
        x = 5 / y;
    }
    __finally
    {
        printf( "In finally\n" );
    }
}
void trans_func( unsigned int u, EXCEPTION_POINTERS* pExp )
{
    printf( "In trans_func.\n" );
    throw SE_Exception();
}

Embora a funcionalidade fornecida por _set_se_translator não está disponível no código gerenciado, é possível usar esse mapeamento em código nativo, mesmo se esse código nativo está em uma compilação na opção de /clr , contanto que o código nativo é indicado usando #pragma unmanaged. Se uma exceção estruturado está sendo gerada em código gerenciado que deve ser mapeado, o código que gerencia e os identificadores a exceção devem ser marcados com pragma. O código a seguir mostra um uso possível. Para obter mais informações, consulte Diretivas Pragma e a palavra-chave __Pragma.

// crt_set_se_translator_clr.cpp
// compile with: /clr
#include <windows.h>
#include <eh.h>
#include <assert.h>
#include <stdio.h>

int thrower_func(int i) {
   int j = i/0;
  return 0;
}

class CMyException{
};

#pragma unmanaged
void my_trans_func(unsigned int u, PEXCEPTION_POINTERS pExp )
{
printf("Translating the structured exception to a C++"
             " exception.\n");
throw CMyException();
}

void DoTest()
{
    try
    {
      thrower_func(10);
    } 

    catch(CMyException e)
    {
printf("Caught CMyException.\n");
    }
    catch(...)
    {
      printf("Caught unexpected SEH exception.\n");
    }
}
#pragma managed

int main(int argc, char** argv) {
    _set_se_translator(my_trans_func);
    DoTest();
    return 0;
}