try-except, instructiontry-except Statement

Section spécifique à MicrosoftMicrosoft Specific

Le essayez-sauf instruction est une extension Microsoft C et langages C++ qui prend en charge de gestion des exceptions structurées.The try-except statement is a Microsoft extension to the C and C++ languages that supports structured exception handling.

SyntaxeSyntax

__Essayez__try
{{
    code protégé    // guarded code
}}
__à l’exception ( expression )__except ( expression )
{{
    code du Gestionnaire d’exception    // exception handler code
}}

NotesRemarks

Le essayez-sauf instruction est une extension Microsoft C et langages C++ qui permet aux applications cibles obtenir des contrôlent lorsque surviennent des événements qui terminent normalement l’exécution du programme.The try-except statement is a Microsoft extension to the C and C++ languages that enables target applications to gain control when events that normally terminate program execution occur. Ces événements sont appelés exceptions, et le mécanisme des exceptions est appelé structurée des exceptions (SEH).Such events are called exceptions, and the mechanism that deals with exceptions is called structured exception handling (SEH).

Pour plus d’informations, consultez le instruction try-finally.For related information, see the try-finally statement.

Les exceptions peuvent être basées sur le matériel ou sur des logiciels.Exceptions can be either hardware-based or software-based. Même quand les applications ne peuvent pas complètement récupérer à partir d'exceptions matérielles ou logicielles, la gestion structurée des exceptions permet d'afficher des informations sur l'erreur et d'intercepter l'état interne de l'application pour favoriser le diagnostic du problème.Even when applications cannot completely recover from hardware or software exceptions, structured exception handling makes it possible to display error information and trap the internal state of the application to help diagnose the problem. Ceci s'avère particulièrement utile pour les problèmes intermittents qui ne peuvent pas être facilement reproduits.This is especially useful for intermittent problems that cannot be reproduced easily.

Note

La gestion structurée des exceptions fonctionne avec Win32 pour les fichiers sources C et C++.Structured exception handling works with Win32 for both C and C++ source files. Toutefois, elle n'est pas conçue spécifiquement pour C++.However, it is not specifically designed for C++. Vous pouvez vous assurer que votre code est plus portable en utilisant la gestion des exceptions C++.You can ensure that your code is more portable by using C++ exception handling. En outre, la gestion des exceptions C++ est plus souple, car elle permet de traiter des exceptions de tout type.Also, C++ exception handling is more flexible, in that it can handle exceptions of any type. Pour les programmes C++, il est recommandé d’utiliser le mécanisme de gestion des exceptions C++ (try, catch et throw instructions).For C++ programs, it is recommended that you use the C++ exception-handling mechanism (try, catch, and throw statements).

L’instruction composée après la __try clause est le corps ou la section protégée.The compound statement after the __try clause is the body or guarded section. L’instruction composée après la __except clause est le Gestionnaire d’exceptions.The compound statement after the __except clause is the exception handler. Le gestionnaire spécifie un ensemble d'actions à entreprendre si une exception est levée pendant l'exécution du corps de la section protégée.The handler specifies a set of actions to be taken if an exception is raised during execution of the body of the guarded section. L'exécution se déroule comme suit :Execution proceeds as follows:

  1. La section protégée est exécutée.The guarded section is executed.

  2. Si aucune exception ne se produit pendant l’exécution de la section protégée, l’exécution se poursuit à l’instruction après le __except clause.If no exception occurs during execution of the guarded section, execution continues at the statement after the __except clause.

  3. Si une exception se produit pendant l’exécution de la section protégée ou dans toute routine de la section protégée, la __except expression (appelée la filtre expression) est évaluée et la valeur détermine comment l’exception est gérée.If an exception occurs during execution of the guarded section or in any routine the guarded section calls, the __except expression (called the filter expression) is evaluated and the value determines how the exception is handled. Il existe trois valeurs possibles :There are three possible values:

    • Exception de EXCEPTION_CONTINUE_EXECUTION (-1) a été abandonnée.EXCEPTION_CONTINUE_EXECUTION (-1) Exception is dismissed. Poursuivre l'exécution au point où l'exception s'est produite.Continue execution at the point where the exception occurred.

    • Exception de EXCEPTION_CONTINUE_SEARCH (0) n’est pas reconnue.EXCEPTION_CONTINUE_SEARCH (0) Exception is not recognized. Poursuivre la recherche d’un gestionnaire dans la pile, en premier pour qu’il contienne des instructions try-except, puis pour les gestionnaires avec la priorité la plus élevée suivante.Continue to search up the stack for a handler, first for containing try-except statements, then for handlers with the next highest precedence.

    • Exception_execute_handler (1) l’Exception est reconnue.EXCEPTION_EXECUTE_HANDLER (1) Exception is recognized. Transférer le contrôle au gestionnaire d’exceptions en exécutant la __except une instruction composée, puis poursuivre l’exécution après le __except bloc.Transfer control to the exception handler by executing the __except compound statement, then continue execution after the __except block.

Étant donné que le __except expression est évaluée comme une expression C, elle est limitée à une valeur unique, l’opérateur d’expression conditionnelle ou l’opérateur virgule.Because the __except expression is evaluated as a C expression, it is limited to a single value, the conditional-expression operator, or the comma operator. Si un traitement plus étendu est requis, l'expression peut appeler une routine qui retourne l'une des trois valeurs répertoriées ci-dessus.If more extensive processing is required, the expression can call a routine that returns one of the three values listed above.

Chaque application peut avoir son propre gestionnaire d'exceptions.Each application can have its own exception handler.

Il n’est pas valide de sauter dans une __try mais valide de sauter hors d’une instruction.It is not valid to jump into a __try statement, but valid to jump out of one. Le Gestionnaire d’exceptions n’est pas appelé si un processus est terminé au milieu de l’exécution un essayez-sauf instruction.The exception handler is not called if a process is terminated in the middle of executing a try-except statement.

Pour assurer la compatibilité avec les versions précédentes, _try, _except, et _leave sont synonymes de __try, __except , et __leave , sauf si option du compilateur /Za (désactiver les extensions de langage) est spécifié.For compatibility with previous versions, _try, _except, and _leave are synonyms for __try, __except, and __leave unless compiler option /Za (Disable language extensions) is specified.

Mot clé __leaveThe __leave Keyword

Le __leave mot clé est valide uniquement dans la section protégée d’un essayez-sauf instruction et son effet consiste à accéder à la fin de la section protégée.The __leave keyword is valid only within the guarded section of a try-except statement, and its effect is to jump to the end of the guarded section. L'exécution se poursuit à la première instruction située après le gestionnaire d'exceptions.Execution continues at the first statement after the exception handler.

Un goto instruction peut également sortir de la section protégée, et il ne réduit pas les performances comme il le fait un try-finally instruction parce que le déroulement de pile ne figure pas.A goto statement can also jump out of the guarded section, and it does not degrade performance as it does in a try-finally statement because stack unwinding does not occur. Toutefois, nous vous recommandons d’utiliser le __leave mot-clé au lieu d’un goto instruction parce que vous êtes moins enclin à commettre une erreur de programmation si la section protégée est volumineux ou complexes.However, we recommend that you use the __leave keyword rather than a goto statement because you are less likely to make a programming mistake if the guarded section is large or complex.

Fonctions intrinsèques de gestion structurée des exceptionsStructured Exception Handling Intrinsic Functions

Gestion structurée des exceptions fournit deux fonctions intrinsèques qui sont disponibles à utiliser avec le essayez-sauf instruction : GetExceptionCode et GetExceptionInformation.Structured exception handling provides two intrinsic functions that are available to use with the try-except statement: GetExceptionCode and GetExceptionInformation.

GetExceptionCode Retourne le code (un entier 32 bits) de l’exception.GetExceptionCode returns the code (a 32-bit integer) of the exception.

La fonction intrinsèque GetExceptionInformation retourne un pointeur vers une structure contenant des informations supplémentaires relatives à l’exception.The intrinsic function GetExceptionInformation returns a pointer to a structure containing additional information about the exception. Ce pointeur vous permet d'accéder à l'état de l'ordinateur qui existait au moment d'une exception matérielle.Through this pointer, you can access the machine state that existed at the time of a hardware exception. La structure est la suivante :The structure is as follows:

typedef struct _EXCEPTION_POINTERS {
    PEXCEPTION_RECORD ExceptionRecord;
    PCONTEXT ContextRecord;
} EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;

Les types pointeur PEXCEPTION_RECORD et PCONTEXT sont définis dans le fichier include <winnt.h >, et _EXCEPTION_RECORD et _CONTEXT sont définis dans le fichier include <excpt.h >The pointer types PEXCEPTION_RECORD and PCONTEXT are defined in the include file <winnt.h>, and _EXCEPTION_RECORD and _CONTEXT are defined in the include file <excpt.h>

Vous pouvez utiliser GetExceptionCode dans le Gestionnaire d’exceptions.You can use GetExceptionCode within the exception handler. Toutefois, vous pouvez utiliser GetExceptionInformation uniquement au sein de l’expression de filtre d’exception.However, you can use GetExceptionInformation only within the exception filter expression. Les informations qu'il désigne sont généralement sur la pile et ne sont plus disponibles lorsque le contrôle est transféré au gestionnaire d'exceptions.The information it points to is generally on the stack and is no longer available when control is transferred to the exception handler.

La fonction intrinsèque AbnormalTermination est disponible au sein d’un gestionnaire de terminaisons.The intrinsic function AbnormalTermination is available within a termination handler. Elle retourne 0 si le corps de la try-finally instruction se termine séquentiellement.It returns 0 if the body of the try-finally statement terminates sequentially. Dans tous les autres cas, elle retourne 1.In all other cases, it returns 1.

excpt.h définit d’autres noms pour ces fonctions intrinsèques :excpt.h defines some alternate names for these intrinsics:

GetExceptionCode équivaut à _exception_codeGetExceptionCode is equivalent to _exception_code

GetExceptionInformation équivaut à _exception_infoGetExceptionInformation is equivalent to _exception_info

AbnormalTermination équivaut à _abnormal_terminationAbnormalTermination is equivalent to _abnormal_termination

ExempleExample

// exceptions_try_except_Statement.cpp
// Example of try-except and try-finally statements
#include <stdio.h>
#include <windows.h> // for EXCEPTION_ACCESS_VIOLATION
#include <excpt.h>

int filter(unsigned int code, struct _EXCEPTION_POINTERS *ep)
{
    puts("in filter.");
    if (code == EXCEPTION_ACCESS_VIOLATION)
    {
        puts("caught AV as expected.");
        return EXCEPTION_EXECUTE_HANDLER;
    }
    else
    {
        puts("didn't catch AV, unexpected.");
        return EXCEPTION_CONTINUE_SEARCH;
    };
}

int main()
{
    int* p = 0x00000000;   // pointer to NULL
    puts("hello");
    __try
    {
        puts("in try");
        __try
        {
            puts("in try");
            *p = 13;    // causes an access violation exception;
        }
        __finally
        {
            puts("in finally. termination: ");
            puts(AbnormalTermination() ? "\tabnormal" : "\tnormal");
        }
    }
    __except(filter(GetExceptionCode(), GetExceptionInformation()))
    {
        puts("in except");
    }
    puts("world");
}

SortieOutput

hello
in try
in try
in filter.
caught AV as expected.
in finally. termination:
        abnormal
in except
world

FIN de la section spécifique à MicrosoftEND Microsoft Specific

Voir aussiSee also

Écriture d’un gestionnaire d’exceptionsWriting an Exception Handler
Gestion structurée des exceptions (C/C++)Structured Exception Handling (C/C++)
Mots clésKeywords