_set_se_translator

 

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

Controla las excepciones Win32 (excepciones estructuradas de C) como con excepciones con tipo de C++.

_se_translator_function _set_se_translator(  
   _se_translator_function seTransFunction  
);  

Parámetros

seTransFunction
Puntero a una C había estructurado de función de traductor de excepciones que se escribe.

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

El _set_se_translator función proporciona un medio para controlar las excepciones Win32 (excepciones estructuradas de C) como C++ con excepciones con tipo. Para permitir que cada excepción de C a C++ controlando catch controlador, primero defina una clase contenedora de excepciones de C que se puede utilizar o derivada de atribuir un tipo de clase concreto a una excepción de C. Para utilizar esta clase, instalar una función personalizada de traductor de excepciones de C que se llama mediante el mecanismo de control de excepciones interno cada vez que se produce una excepción de C. Dentro de la función de traductor puede producir cualquier excepción con tipo que se puede detectar mediante C++ coincidente catch controlador.

Debe usar /EHa al utilizar _set_se_translator.

Para especificar una función de traducción personalizada, llame a _set_se_translator con el nombre de la función de traducción como su argumento. La función de traductor que escriba se llama una vez por cada llamada de función en la pila que tenga try bloques. No hay ninguna función de traductor de forma predeterminada.

La función de traductor debe hacer nada más de arrojar C++ con el tipo de excepción. Si lo hace algo además de producir (como escribir en un archivo de registro, por ejemplo) el programa podría no funcionar como se esperaba, porque el número de veces que se invoca la función de traductor es depende de la plataforma.

En un entorno multiproceso, funciones de traductor se mantienen por separado para cada subproceso. Cada nuevo subproceso necesita para instalar su propia función de traductor. Por lo tanto, cada subproceso está a cargo de su propio control de traducción. _set_se_translatores específico de un subproceso; otra DLL puede instalar una función de conversión diferentes.

El seTransFunction función que escriba debe ser una función compilada nativo (no se compila con/CLR). Deben tomar un entero sin signo y un puntero a Win32 _EXCEPTION_POINTERS estructura como argumentos. Los argumentos son los valores devueltos de las llamadas a la API Win32 GetExceptionCode y GetExceptionInformation funciones, respectivamente.

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

Para _set_se_translator, hay implicaciones al vincular dinámicamente a CRT; otra podría llamar DLL en el proceso _set_se_translator y reemplace el controlador de su propio.

Al utilizar _set_se_translator desde código administrado (código compilado con/CLR) o mezclar código nativo y administrado, tenga en cuenta que el traductor afecta a las excepciones generadas en código nativo solamente. Cualquier administrado las excepciones generadas en código administrado (por ejemplo, cuando generar System::Exception) no se enrutan a través de la función de traductor. Las excepciones producidas en código administrado mediante la función de Win32 RaiseException o causa una excepción del sistema como una división por cero se enrutan a través del traductor.

RutinaEncabezado necesario
_set_se_translator<eh.h></eh.h>

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

Para obtener más información sobre compatibilidad, vea Compatibility en la introducción.

// 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.  

Aunque la funcionalidad proporcionada por _set_se_translator está disponible en código administrado, es posible utilizar esta asignación en código nativo, incluso si ese código nativo está en una compilación en el /clr cambie, siempre que el código nativo se indica mediante #pragma unmanaged. Si es que se produce una excepción estructurada en código administrado que se asignarán, el código que genera y controla la excepción debe marcarse con el pragma. El código siguiente muestra un uso posible. Para obtener más información, consulte directivas Pragma y la palabra clave __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.  

No es aplicable. Para llamar a la función estándar de C, use PInvoke. Para obtener más información, vea Ejemplos de invocación de plataforma.

Rutinas de control de excepciones
set_terminate
set_unexpected
Finalizar
inesperado

Mostrar: