_set_se_translator

Artigo
08/25/2010

Manipula sistema autônomo exceções Win32 (C estruturada de exceções) sistema autônomo C++ digitado exceções.

_se_translator_function _set_se_translator(
   _se_translator_function seTransFunction
);

Parâmetros

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

Valor de retorno

Retorna um ponteiro para a função anterior do conversor registrada por _set_se_translator, para que a função anterior pode ser restaurada posteriormente. Se nenhuma função anterior tiver sido definida, o valor retornado pode ser usado restauração o comportamento padrão; esse valor pode ser nulo.

Comentários

The _set_se_translator função fornece uma maneira de lidar com exceções Win32 (C estruturada de exceções) sistema autônomo C++ digitado exceções. Para permitir que cada exceção C deve ser tratado por um C++ catch manipulador, primeiro defina uma classe wrapper exceção C que pode ser usada ou derivada para um tipo de classe específica de atributo a uma exceção C. Para usar essa classe, instale uma função de conversor C de exceção personalizada que é chamada pelo mecanismo de tratamento de exceção interno sempre que uma exceção de C é disparado.Dentro de sua função conversor, você pode lançar qualquer exceção de tipos que pode ser detectada por um correspondente de C++ catch manipulador.

Você deve usar / EHa quando_set_se_translator.

Para especificar uma função de conversão personalizada, telefonar _set_se_translator com o nome da sua função de conversão sistema autônomo seu argumento. O conversor de função que você gravar é chamado assim que para cada chamada de função na pilha que tem try blocos. Não há nenhuma função de conversor padrão.

Sua função tradutor deve fazer não mais do que lançam uma C++ digitado exceção.Se tiver qualquer coisa em adição a lançar (sistema autônomo gravar um arquivo de log, por exemplo) seu programa pode não se comportar conforme o esperado, porque o número de vezes que a função do tradutor é chamada é dependente de plataforma.

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

The seTransFunction função que você gravar deve ser uma função compilado nativo (não compilada com/CLR). Ele precisa obter um inteiro sem sinal e um ponteiro para um Win32 _EXCEPTION_POINTERS estrutura sistema autônomo 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* );

For _set_se_translator, há implicações quando vinculando dinamicamente a CRT; outra DLL em processo pode chamar _set_se_translator e substitua o manipulador com seu próprio.

Ao usar _set_se_translator no 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 em código nativo somente. Qualquer gerenciados exceções geradas em código gerenciado (sistema autônomo quando disparar System::Exception) não são roteados por meio da função do tradutor. Exceções aumentadas em código gerenciado usando o Win32 funcionam RaiseException ou causado por uma exceção de sistema como uma divisão por zero exceção são roteadas através do 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: puroopção do 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();
}

In trans_func. In finally Caught a __try exception with 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 que o código nativo esteja em uma compilação na /clr comutador, sistema autônomo longo sistema autônomo o código nativo é indicado usando #pragma unmanaged. Se for sendo lançada uma exceção estruturada no código gerenciado deve ser mapeada, o código que gera e manipule a exceção deve ser marcado com o pragma. O código a seguir mostra um uso possível.For more information, see As diretivas cabeçalho 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;
}

Translating the structured exception to a C++ exception. Caught CMyException.