try block

Eine Exception , die in einem try -Block geworfen wird, kann möglicherweise von einem zugehörigen Handler behandelt werden.

Syntax

Gewöhnlicher try -Block

Ein gewöhnlicher try -Block ist eine Anweisung .

Wenn eine Ausnahme aus ihrem compound-statement geworfen wird, wird die Ausnahme mit den Handlern in ihrer handler-seq abgeglichen:

void f()
{
    throw 1;     // WIRD NICHT vom Handler unten behandelt
    try
    {
        throw 2; // wird vom zugehörigen Handler behandelt
    }
    catch (...)
    {
        // behandelt die Exception 2
    }
    throw 3;     // WIRD NICHT vom Handler oben behandelt
}

Funktion try -Block

Ein try -Block ist eine spezielle Art von Funktionskörper .

Wenn eine Ausnahme aus ihrem compound-statement oder ctor-initializer (falls vorhanden) geworfen wird, wird die Ausnahme mit den Handlern in ihrer handler-seq abgeglichen:

int f(bool cond)
{
    if (cond)
        throw 1;
    return 0;
}
struct X
{
    int mem;
    X() try : mem(f(true)) {}
    catch (...)
    {
        // behandelt die Ausnahme 1
    }
    X(int) try
    {
        throw 2;
    }
    catch (...)
    {
        // behandelt die Ausnahme 2
    }
};

Ausnahmen, die in Destruktoren von Objekten mit statischer Speicherdauer oder in Konstruktoren von Objekten, die mit Nicht-Block-Variablen mit statischer Speicherdauer assoziiert sind, werden nicht von einem Funktions- try -Block der main -Funktion abgefangen.

Das Verlassen des Endes der compound-statement eines Handlers eines Funktions- try -Blocks entspricht dem Verlassen des Endes der compound - statement dieses Funktions- try -Blocks, es sei denn, die Funktion ist ein Konstruktor oder Destruktor (siehe unten).

Konstruktor und Destruktor try Block

Für eine Klasse C , wenn der Funktionskörper ihrer Konstruktor- oder Destruktordefinition ein try -Block ist und während der Initialisierung bzw. Zerstörung der Unterobjekte von C eine Exception ausgelöst wird, wird diese Exception ebenfalls mit den Handlern in der Handler-Sequenz  des try -Blocks abgeglichen:

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 (...)
    {
        // behandelt die Exception 1
    }
    ~Y() try {}
    catch (...)
    {
        // behandelt die Exception 2
    }
};

Das Verweisen auf ein nicht-statisches Mitglied oder eine Basisklasse eines Objekts im Handler für einen try -Block einer Funktion im Konstruktor oder Destruktor dieses Objekts führt zu undefiniertem Verhalten.

Wenn eine return -Anweisung in einem Handler des try -Blocks eines Konstruktors erscheint, ist das Programm fehlerhaft.

Die aktuell behandelte Exception wird erneut ausgelöst, wenn die Steuerung das Ende eines Handlers des try -Blocks eines Konstruktors oder Destruktors erreicht.

Ablaufsteuerung

Die compound-statement eines try -Blocks ist eine control-flow-limited statement :

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

Eine Sprunganweisung ( goto , break , return , continue ) kann verwendet werden, um die Steuerung aus einem try -Block (einschließlich seiner Handler) zu übertragen. Wenn dies geschieht, wird jede Variable, die im try -Block deklariert wurde, im Kontext zerstört, der ihre Deklaration direkt enthält:

try
{
    T1 t1;
    try
    {
        T2 t2;
        goto label; // zerstöre zuerst t2, dann t1
    }
    catch(...)
    {
        // wird ausgeführt, falls eine Exception beim Zerstören von t2 geworfen wird
    }
}
catch(...)
{
    // wird ausgeführt, falls eine Exception beim Zerstören von t1 geworfen wird
}
label: ;

Schlüsselwörter

try

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch

• Auslösen von Ausnahmen
• Behandeln von Ausnahmen