_set_se_translator

Artículo
04/10/2013

Las excepciones Win32 de identificadores (excepciones estructuradas C) como C++ con excepciones.

_se_translator_function _set_se_translator(
   _se_translator_function seTransFunction
);

Parámetros

seTransFunction
Puntero a la función estructurada C. el traductor de excepción que escribe.

Valor devuelto

Devuelve un puntero a la función anterior de traductor registrada por _set_se_translator, para poder restaurar la función anterior más adelante.Si no se ha establecido ninguna función anterior, el valor devuelto se puede utilizar para restaurar el comportamiento predeterminado; este valor puede ser NULL.

Comentarios

La función de _set_se_translator proporciona una manera de controlar las excepciones Win32 (excepciones estructuradas C) como C++ escrito excepciones.Para permitir a cada excepción de C es administrada por el controlador de C++. catch , primero define la clase contenedora de la excepción de C/C++. que puede utilizar, o derivado de, el atributo una clase concreta escrita a la excepción de C/C++.Para utilizar esta clase, instale una función personalizada del traductor de excepción de C denominada por la excepción interna de C/C++. el mecanismo de control de excepciones se provoca cada vez.Dentro de la función traductor, puede producir cualquier excepción de tipo se puede detectar mediante un controlador coincidente de C++ catch .

Debe utilizar /EHa al utilizar _set_se_translator.

Para especificar una función personalizada de traducción, llame a _set_se_translatorcon el nombre de la función de traducción como argumento.La función de traductor que se escribe llama una vez para cada invocación de función en la pila que tiene bloques de try.No hay ninguna función predeterminada del traductor.

La función de traductor debe hacer no más que la excepción tipo ++ de C/C++.Si hace nada además de producir (como escribir en un archivo de registro, por ejemplo) el programa podría comportarse como se espera, porque el número de veces que se llama a la función de traductor función es.

En un entorno multiproceso, las funciones de traductor se mantienen por separado para cada subproceso.Cada nuevo subproceso necesita instalar su propia función de traductor.Así, cada subproceso está responsable de su propia administración de traducción._set_se_translatores específico de un subproceso; otra DLL puede instalar otra función de traducción.

La función de seTransFunction que se escriba debe ser una función natural-compilada (no compilada con /clr).Debe contener un entero sin signo y un puntero a una estructura de Win32 _EXCEPTION_POINTERS como argumentos.los argumentos son los valores devueltos de llamadas a la API Win32 GetExceptionCode y GetExceptionInformation funciona, respectivamente.

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

Para _set_se_translator, hay implicaciones al vincular dinámicamente a CRT; otra DLL en el proceso puede llamar a _set_se_translator y reemplazar el controlador con el suyo.

Al utilizar _set_se_translator de código administrado (código compilado con /clr) o nativo nativo y código administrado, tenga en cuenta que el traductor afecta a las excepciones generadas en código nativo únicamente.Ninguna excepción administrada generada en código administrado (por ejemplo al activar System::Exception) no se distribuyen con la función de traductor.Las excepciones producidas en código administrado mediante la función RaiseException Win32 o producidas por una excepción del sistema como una división por la excepción cero se enrutan a través del traductor.

Requisitos

rutina	Encabezado necesario
_set_se_translator	<eh.h>

La funcionalidad proporcionada por _set_se_translator no está disponible en el código compilado con la opción del compilador /clr: puro .

Para obtener más información de compatibilidad, vea compatibilidad en la Introducción.

Ejemplo

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

Aunque la funcionalidad proporcionada por _set_se_translator no está disponible en código administrado, es posible utilizar esta asignación en código nativo, aunque dicho código nativo está en una compilación en modificador /clr , mientras el código nativo se indica mediante #pragma unmanaged.Si una excepción estructurada se está iniciando en el código administrado que se debe asignar, el código que genera y los controla la excepción se deben marcar con pragma.El código siguiente muestra un posible uso.Para obtener más información, vea Directivas de pragma y la palabra clave de __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;
}