_set_se_translator

Article
03/26/2013

Les exceptions Win32 de handles (exceptions structurées C) comme C++ avez tapé des exceptions.

_se_translator_function _set_se_translator(
   _se_translator_function seTransFunction
);

Paramètres

seTransFunction
Pointeur vers une fonction de transcodage structurée des exceptions c que vous écrivez.

Valeur de retour

Retourne un pointeur vers une fonction de transcodage précédente stockée par _set_se_translator, afin que la fonction précédente puisse être restaurées ultérieurement.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.

Notes

La fonction d' _set_se_translator permet de gérer des exceptions Win32 (exceptions structurées C) comme exceptions typées par C++.Pour permettre à chacun l'exception C à gérer par le gestionnaire C++ catch , définissez initialement la classe wrapper d'exception c qui peut être utilisée, ou dérivé de, pour attribuer un type spécifique de la classe à l'exception c.Pour utiliser cette classe, installez une fonction de transcodage personnalisée d'exception C qui est appelée par l'exception interne c de mécanisme de gestion des exceptions chaque fois que est levée.Dans votre fonction de transcodage, vous pouvez lever une exception typée qui peut être interceptée par un gestionnaire de la correspondance C++ catch .

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

Pour spécifier une fonction personnalisée de traduction, appelez _set_se_translatoravec le nom de la fonction de l'interprétation en tant qu'argument.La fonction de transcodage que vous entrez est appelée une fois pour chaque appel de fonction sur la pile qui a des blocs d' try.Aucune fonction de transcodage par défaut.

Votre fonction de transcodage ne doit faire pas plus que de lever l'exception typée par C++.S'il a une valeur en plus de lever d'exception (par exemple l'écriture dans un fichier journal par exemple), votre programme peut ne pas se comporter comme prévu, car le nombre de fois que la fonction de transcodage est appelée est le la plateforme.

Dans un environnement multithread, les fonctions de transcodage sont conservées séparément pour chaque thread.Besoins de chaque les nouveaux threads d'installer sa propre fonction de transcodage.ainsi, chaque thread est responsable de sa propre gestion de traduction._set_se_translatorest spécifique à un thread ; une autre DLL peut installer une autre fonction de traduction.

la fonction d' seTransFunction que vous écrivez doit être une fonction natif-compilée (non compilée avec /clr).Il doit prendre un entier non signé et un pointeur vers une structure Win32 _EXCEPTION_POINTERS comme arguments.Les arguments sont les valeurs de retour des appels à l'API Win32 GetExceptionCode et GetExceptionInformation s'exécute, respectivement.

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

Pour _set_se_translator, il y a des conséquences en liant dynamiquement du CRT ; une autre DLL dans le processus peut appeler _set_se_translator et remplacer votre gestionnaire par son propre.

Lorsque vous utilisez _set_se_translator de code managé (code compilé avec /clr) ou mixte natif et le code managé, sachez que le traducteur affecte des exceptions générées en code natif uniquement.Aucune exception managée générée dans le code managé (tel que lors de le déclenchement System::Exception) n'est routée via la fonction de transcodage.Les exceptions déclenchées dans du code managé à Win32 s'exécutent RaiseException ou provoquée par une exception de système comme un exception de division par zéro sont routés dans le traducteur.

Configuration requise

routine	en-tête requis
_set_se_translator	<eh.h>

La fonctionnalité fournie par _set_se_translator est pas disponible dans le code compilé avec l'option du compilateur de /clr : pure .

Pour plus d'informations de compatibilité, consultez compatibilité dans l'introduction.

Exemple

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

Bien que la fonctionnalité fournie par _set_se_translator soit pas disponible dans du code managé, il est possible d'utiliser ce mappage en code natif, même si ce code natif est dans une compilation sous le commutateur d' /clr , tant que le code natif est 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 se produit et les gère l'exception doivent être marqués avec pragma.Le code suivant illustre une utilisation potentielle.Pour plus d'informations, consultez Directives pragma et le mot clé 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;
}