_set_se_translator

 

Pour obtenir la dernière documentation sur Visual Studio 2017, consultez Documentation Visual Studio 2017.

Gère les exceptions Win32 (exceptions structurées par C) en tant qu'exceptions typées C++.

_se_translator_function _set_se_translator(  
   _se_translator_function seTransFunction  
);  

Paramètres

seTransFunction
Pointeur vers une fonction de traduction d'exceptions structurées C que vous écrivez.

Retourne un pointeur vers la précédente fonction de traduction enregistrée par _set_se_translator, afin qu'elle puisse être restaurée plus tard. Si aucune fonction précédente n'a été définie, la valeur de retour peut être utilisée pour restaurer le comportement par défaut ; cette valeur peut être Null.

La fonction _set_se_translator permet de gérer les exceptions Win32 (exceptions structurées C) en tant qu'exceptions typées C++. Pour que chaque exception C soit gérée par un gestionnaire catch C++, définissez d'abord une classe wrapper d'exceptions C qui peut être utilisée, ou dérivée, pour attribuer un type de classe spécifique à une exception C. Pour utiliser cette classe, installez une fonction de traduction d'exception C personnalisée appelée par le mécanisme de gestion des exceptions interne chaque fois qu'une exception C est levée. Dans votre fonction de traduction, vous pouvez lever n'importe quelle exception typée qui peut être interceptée par un gestionnaire catch C++ correspondant.

Vous devez utiliser /EHa lors de l’utilisation _set_se_translator.

Pour spécifier une fonction de traduction personnalisée, appelez _set_se_translator avec le nom de votre fonction de traduction comme argument. La fonction de traduction que vous écrivez est appelée une fois pour chaque appel de fonction sur la pile qui a try blocs. Il n'existe aucune fonction de traduction par défaut.

Votre fonction de traduction se contente de lever une exception typée C++. Si elle effectue d'autres actions (écrire dans un fichier journal, par exemple), votre programme risque de ne pas se comporter comme prévu, car le nombre de fois où la fonction de traduction est appelée dépend de la plateforme.

Dans un environnement multithread, les fonctions de traduction sont gérées séparément pour chaque thread. Chaque nouveau thread doit installer sa propre fonction de traduction. Par conséquent, chaque thread est responsable de sa propre gestion de traduction. _set_se_translatorest spécifique à un thread ; une autre DLL peut installer une fonction de traduction différente.

La fonction seTransFunction que vous écrivez doit être une fonction compilée en code natif (pas compilée avec /clr). Elle doit utiliser un entier non signé et un pointeur vers une structure Win32 _EXCEPTION_POINTERS comme arguments. Les arguments sont les valeurs de retour des appels aux fonctions API Win32 GetExceptionCode et GetExceptionInformation, respectivement.

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

Pour _set_se_translator, la liaison dynamique au CRT a des conséquences ; une autre DLL du processus peut appeler _set_se_translator et remplacer votre gestionnaire par le sien.

Lorsque vous utilisez _set_se_translator à partir du code managé (code compilé avec /clr) ou du code natif et managé mixte, sachez que le traducteur affecte les exceptions générées en code natif uniquement. Les exceptions managées générées en code managé (par exemple, en déclenchant System::Exception) ne sont pas acheminées par le biais de la fonction de traduction. Les exceptions générées en code managé à l'aide de la fonction Win32 RaiseException ou provoquées par une exception système telle qu'une exception de division par zéro sont acheminées via le traducteur.

RoutineEn-tête requis
_set_se_translator<eh.h>

La fonctionnalité fournie par _set_se_translator n’est pas disponible dans le code compilé avec le /CLR : pure option du compilateur.

Pour plus d’informations sur la compatibilité, consultez Compatibility dans l’introduction.

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

Bien que les fonctionnalités fournies par _set_se_translator ne soient pas disponibles en code managé, il est possible d'utiliser ce mappage en code natif même si ce code natif se trouve dans une compilation sous le commutateur /clr, à condition qu'il soit indiqué à l'aide de #pragma unmanaged. Si une exception structurée est levée dans le code managé qui doit être mappé, le code qui génère et gère l'exception doit être marqué avec le pragma. Le code suivant illustre une utilisation possible. Pour plus d’informations, consultez Directives Pragma et le mot clé _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.  

Non applicable. Pour appeler la fonction C standard, utilisez PInvoke. Pour plus d'informations, consultez Exemples d'appel de plateforme.

Routines de gestion des exceptions
set_terminate
set_unexpected
arrêter
inattendue

Afficher: