try block

Une exception levée dans un bloc try peut potentiellement être gérée par un gestionnaire associé.

Syntaxe

Bloc try ordinaire

Un bloc try ordinaire est une instruction .

Si une exception est levée depuis son compound-statement , l'exception sera comparée aux handlers dans sa handler-seq :

void f()
{
    throw 1;     // NON géré par le gestionnaire ci-dessous
    try
    {
        throw 2; // géré par le gestionnaire associé
    }
    catch (...)
    {
        // gère l'exception 2
    }
    throw 3;     // NON géré par le gestionnaire ci-dessus
}

Bloc try de fonction

Un bloc de fonction try est un type particulier de corps de fonction .

Si une exception est levée depuis son compound-statement ou son ctor-initializer (le cas échéant), l'exception sera comparée aux handlers dans sa handler-seq :

int f(bool cond)
{
    if (cond)
        throw 1;
    return 0;
}
struct X
{
    int mem;
    X() try : mem(f(true)) {}
    catch (...)
    {
        // gère l'exception 1
    }
    X(int) try
    {
        throw 2;
    }
    catch (...)
    {
        // gère l'exception 2
    }
};

Les exceptions levées dans les destructeurs d'objets ayant une durée de stockage statique ou dans les constructeurs d'objets associés à des variables non-bloc avec durée de stockage statique ne sont pas capturées par un bloc try de fonction sur la main fonction .

Sortir de la fin du compound-statement d'un handler d'un bloc try de fonction est équivalent à sortir de la fin du compound - statement de ce bloc try de fonction, sauf si la fonction est un constructeur ou un destructeur (voir ci-dessous).

Constructeur et destructeur try block

Pour une classe C , si le corps de la fonction de sa définition de constructeur ou de destructeur est un bloc try de fonction, et qu'une exception est levée pendant l'initialisation ou la destruction, respectivement, des sous-objets de C , l'exception sera également comparée aux gestionnaires dans la séquence-de-gestionnaires  du bloc try de fonction :

int f(bool cond = true)
{
    if (cond)
        throw 1;
    return 0;
}
struct X
{
    int mem = f();
    ~X()
    {
        throw 2;
    }
};
struct Y
{
    X mem;
    Y() try {}
    catch (...)
    {
        // gère l'exception 1
    }
    ~Y() try {}
    catch (...)
    {
        // gère l'exception 2
    }
};

Se référer à tout membre non statique ou classe de base d'un objet dans le gestionnaire d'un bloc try d'un constructeur ou destructeur pour cet objet entraîne un comportement indéfini.

Si une return instruction apparaît dans un gestionnaire du bloc try de fonction d'un constructeur, le programme est mal formé.

L' exception actuellement gérée est relancée si le contrôle atteint la fin d'un gestionnaire du bloc try de fonction d'un constructeur ou destructeur.

Flux de contrôle

La compound-statement d'un bloc try est une instruction à flux de contrôle limité :

void f()
{
    goto label;     // erreur
    try
    {
        goto label; // OK
        label: ;
    }
    catch (...)
    {
        goto label; // erreur
    }
}

Une instruction de saut ( goto , break , return , continue ) peut être utilisée pour transférer le contrôle hors d'un try block (y compris ses gestionnaires). Lorsque cela se produit, chaque variable déclarée dans le try block sera détruite dans le contexte qui contient directement sa déclaration :

try
{
    T1 t1;
    try
    {
        T2 t2;
        goto label; // détruire d'abord t2, puis t1
    }
    catch(...)
    {
        // exécuté si une exception est levée lors de la destruction de t2
    }
}
catch(...)
{
    // exécuté si une exception est levée lors de la destruction de t1
}
label: ;

Mots-clés

try

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi

• Lancer des exceptions
• Gérer les exceptions