essai-excepté l'instruction
Spécifique à Microsoft
La syntaxe suivante décrit une instruction try-except l'instruction :
__try
{
// guarded code
}
__except ( expression )
{
// exception handler code
}
Notes
L'instruction d' instruction try-except est une extension Microsoft aux langages C et C++ qui permet aux applications cibles au contrôle du volume lorsque les événements qui termine normalement l'exécution du programme se produisent.De ces événements sont appelés exceptions, et le mécanisme que les entreprise avec des exceptions est appelé gestion structurée des exceptions.
Pour plus d'informations, consultez instruction de try-finally.
Les exceptions peuvent être réalisées par le matériel ou articulées sur le logiciel.Même lorsque les applications ne peuvent pas complètement récupérer des exceptions matérielle ou logicielle, la gestion structurée des exceptions permet d'afficher des informations sur l'erreur et pour intercepter l'état interne de l'application de manière à diagnostiquer le problème.Cela est particulièrement utile pour les problèmes par intermittence qui ne peuvent pas être reproduits facilement.
[!REMARQUE]
La gestion structurée des exceptions fonctionne avec Win32 pour les fichiers sources C et C++.Toutefois, il n'est pas conçu pour C++.Vous pouvez garantir que votre code est plus portable à l'aide de la gestion des exceptions C++.En outre, la gestion des exceptions C++ est plus flexible, car elle peut gérer les exceptions de tout type.Pour les programmes C++, il est recommandé d'utiliser le mécanisme de gestion des exceptions C++ (instructions detentative, Catch, et jet ).
l'instruction composée après la clause d' __try est le corps ou la section protégée.l'instruction composée après la clause d' __except est le gestionnaire d'exceptions.Le gestionnaire spécifie un jeu d'actions à entreprendre si une exception est levée pendant l'exécution du corps de la section protégée.L'exécution se poursuit comme suit :
la section protégée est exécutée.
si aucune exception ne se produit pendant l'exécution de la section protégée, l'exécution continue à l'instruction après la clause d' __except .
Si une exception se produit pendant l'exécution de la section protégée ou dans toute routine les appels protégés de section,*l'expression * d' __except(appelée l'expression de filtre ) est évaluée et la valeur détermine comment l'exception est gérée.Il existe trois valeurs suivantes :
L'exception d'**EXCEPTION_CONTINUE_EXECUTION (- 1)**est fermée.Poursuivre l'exécution au moment où l'exception s'est produite.
L'exception d'**EXCEPTION_CONTINUE_SEARCH (0)**n'est pas marquée.Continuez à explorer en haut de la pile pour un gestionnaire, en premier pour contenir des instructions d' instruction try-except , puis pour les gestionnaires ayant la priorité la plus élevée suivante.
L'exception d'**EXCEPTION_EXECUTE_HANDLER (1)**est reconnue.Le contrôle de migration vers le gestionnaire d'exceptions en exécutant l'instruction composée d' __except , continuez l'exécution après le bloc d' __except .
Étant donné que l'expression desauf de est évaluée comme expression c, elle est limitée à une valeur unique, à l'opérateur d'expression conditionnelle, ou à l'opérateur virgule.Si un traitement plus étendu est requis, l'expression peut appeler une routine qui retourne une des trois valeurs répertoriées ci-dessus.
chaque application peut avoir son propre gestionnaire d'exceptions.
Il n'est pas valide pour accéder dans une instruction d' __try , mais non valide pour ignorer d'une.Le gestionnaire d'exceptions n'est pas appelé si un processus est terminé au milieu de l'exécution d'une instruction d' instruction try-except .
Pour plus d'informations, consultez l'article de la Base de connaissances Q315937 : COMMENT : Dépassement de capacité de la pile d'interruption dans une application Visual C++.
Le mot clé de __leave
Le mot clé d' __leave est valide uniquement dans la section protégée d'une instruction d' try-except , et son effet d'accéder à la fin de la section protégée.l'exécution continue à la première instruction après le gestionnaire d'exceptions.
Une instruction d' goto peut également ignorer de la section protégée, et il n'altère pas les performances que dans une instruction d' try-finally car le déroulement de pile ne se produit pas.Toutefois, nous vous recommandons d'utiliser le mot clé d' __leave plutôt qu'une instruction d' goto car vous êtes moins susceptible de faire une erreur de programmation si la section protégée est volumineux ou complexe.
.gif "s58ftw19.collapse_all(fr-fr,VS.110).gif")
fonctions intrinsèques de gestion structurée des exceptions
La gestion structurée des exceptions fournit deux fonctions intrinsèques qui sont disponibles pour être utilisés avec l'instruction d' instruction try-except : GetExceptionCode et GetExceptionInformation.
GetExceptionCode retourne un code (un entier 32 bits) de l'exception.
La fonction intrinsèque GetExceptionInformation retourne un pointeur vers une structure contenant des informations supplémentaires sur l'exception.Via ce pointeur, vous pouvez accéder au déclarer d'ordinateur qui existait au moment d'une exception de matériel.La structure est la suivante :
struct _EXCEPTION_POINTERS {
EXCEPTION_RECORD *ExceptionRecord,
CONTEXT *ContextRecord }
_EXCEPTION_RECORD de types pointeur et _CONTEXTE sont définis dans le fichier Include EXCPT.H.
Vous pouvez utiliser GetExceptionCode dans le gestionnaire d'exceptions.Toutefois, vous pouvez utiliser GetExceptionInformation uniquement dans l'expression de filtre d'exception.Les informations qu'elle indique sont généralement sur la pile et ne sont plus disponibles lorsque le contrôle est transféré au gestionnaire d'exceptions.
La fonction intrinsèque AbnormalTermination est disponible dans un gestionnaire de terminaisons.Il retourne 0 si le corps de l'instruction d' try-finally se termine séquentiellement.Dans tous les autres cas, elle retourne 1.
EXCPT.H définit des autres noms pour ces intrinsèques :
GetExceptionCode est équivalent au _exception_code
GetExceptionInformation est équivalent au _exception_information
AbnormalTermination est équivalent au _abnormal_termination
Exemple
// 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");
}
Sortie
hello
in try
in try
in filter.
caught AV as expected.
in finally. termination:
abnormal
in except
world
détail de FIN Microsoft
Voir aussi
Référence
Écrire un gestionnaire d'exceptions