set_se_translator

Artigo
02/25/2013

Manipula as exceções de Win32 (C estruturado de exceções) como C++ digitado exceções.

_se_translator_function _set_se_translator(
   _se_translator_function seTransFunction
);

Parâmetros

seTransFunction
Ponteiro para um c estruturado a função de conversor de exceção que você escreve.

Valor de retorno

Retorna um ponteiro para a função anterior do conversor registrado por _set_se_translator, de modo que a função anterior pode ser restaurada posteriormente.Se nenhuma função anterior tiver sido definida, o valor de retorno pode ser usado para restaurar o comportamento padrão; Esse valor pode ser nulo.

Comentários

O _set_se_translator função fornece um meio para lidar com exceções Win32 (C estruturado de exceções) como C++ digitado exceções.Para permitir que cada exceção c deve ser tratado por um C++ catch manipulador, primeiro defina uma classe de wrapper de exceção c que pode ser usada ou derivada, para um tipo específico de classe de atributo a uma exceção de C.Para usar essa classe, instale uma função de conversor de exceção personalizada de c que é chamada pelo mecanismo de tratamento de exceção interno sempre que uma exceção C.Dentro de sua função de conversor, você pode lançar qualquer exceção tipada que pode ser detectada por uma correspondência C++ catch manipulador.

Você deve usar /EHa ao usar _set_se_translator.

Para especificar uma função de conversão personalizado, chame _set_se_translator com o nome de sua função de conversão como seu argumento.A função do conversor que você escreve é chamada uma vez para cada chamada de função na pilha que tem try blocos.Não há nenhuma função de conversor de padrão.

Sua função tradutor não deve fazer nenhum mais do que lançam um C++ digitado a exceção.Se existir outro recurso além lançando (como gravar em um arquivo de log, por exemplo) de seu programa pode não se comportar conforme o esperado, pois o número de vezes que a função do tradutor é chamada é dependente de plataforma.

Em um ambiente multithread, as funções do tradutor são administradas separadamente para cada segmento.Cada novo segmento precisa instalar sua própria função de conversor.Assim, cada thread é responsável por seu próprio tratamento de tradução._set_se_translator é específico para um segmento; DLL outra pode instalar uma função de conversão diferentes.

O seTransFunction função que você escreve deve ser uma função nativa compilado (não compilada com /clr).Ele deve seguir um inteiro sem sinal e um ponteiro para um Win32 _EXCEPTION_POINTERS estrutura como argumentos.Os argumentos são os valores de retorno de chamadas à API do Win32 GetExceptionCode e GetExceptionInformation funções, respectivamente.

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

Para _set_se_translator, há implicações quando a vinculação dinâmica para a CRT; outra DLL no processo poderia chamar _set_se_translator e substituir o manipulador com seu próprio.

Ao usar o _set_se_translator do código gerenciado (código compilado com /clr) ou misto de código nativo e gerenciado, esteja ciente de que o tradutor afeta exceções geradas no código nativo somente.Qualquer gerenciado exceções geradas em código gerenciado (como quando raising System::Exception) não são roteadas por meio da função do tradutor.Exceções geradas em código gerenciado usando a função Win32 RaiseException ou causado por uma exceção do sistema, como uma divisão por zero exceção são roteadas pelo tradutor.

Requisitos

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

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

Para obter mais informações de 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 pelo _set_se_translator é não disponível em código gerenciado, é possível usar esse mapeamento em código nativo, mesmo que esse código nativo está em uma compilação sob o /clr alternar, enquanto o código nativo é indicado usando #pragma unmanaged.Se uma exceção estruturada é sendo lançada em código gerenciado que deve ser mapeado, o código que gera e manipula a exceção deve ser marcado com o pragma.O código a seguir mostra um possível uso.Para obter mais informações, consulte Diretivas pragma e __Pragma palavra-chave.

// 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;
}