WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Ausnahmesicherheit in C++: grundlegende, starke und No-Throw-Garantie

Die grundlegende Garantie erlaubt Teiländerungen bei gültigem Zustand. Die starke Garantie lässt bei einer Ausnahme keine beobachtbare Änderung zurück. Die No-Throw-Garantie lässt keine Ausnahme zum Aufrufer gelangen.

Version: ISO C++23; implementation support may vary

Syntax

void update_basic(State& live, bool fail);
void update_strong(State& live, bool fail);
void commit(State& live, State& staged) noexcept;

// Copy-and-swap inside update_strong:
State staged = live;
update_basic(staged, fail);
commit(live, staged);

// Inside commit, check the selected swap expression without evaluating it:
static_assert(noexcept(std::swap(live, staged)));

Grundlegende Garantie (basic). Verlässt eine Ausnahme die Operation, gehen keine Ressourcen verloren und die Invarianten der vom Vertrag erfassten Objekte bleiben erhalten. Gültig heißt nicht unverändert: Die erste von zwei Änderungen kann sichtbar bleiben, wenn die zweite eine Ausnahme auslöst.

Starke Garantie (strong). Verlässt eine Ausnahme die Operation, ist der vom Vertrag erfasste Zustand beobachtbar derselbe wie vor dem Aufruf. Bei Erfolg darf er sich ändern. Beim Copy-and-Swap erzeugst du eine unabhängige Kopie und führst alle potenziell auslösenden Änderungen daran durch. Scheitert die Vorbereitung mit einer Ausnahme, bleibt das Original unangetastet. Erst nach erfolgreicher Vorbereitung übernimmst du das Ergebnis durch einen Tausch, der gelingen muss, ohne eine Ausnahme auszulösen. Das temporäre Objekt übernimmt den alten Zustand und gibt ihn bei seiner Zerstörung ohne Ausnahme frei.

No-Throw-Garantie. Sind die Vorbedingungen erfüllt, erreicht keine Ausnahme den Aufrufer. Die Operation kann Ausnahmen intern abfangen oder Fehler anders melden, etwa per Fehlercode. Der Spezifizierer noexcept prüft die Implementierung nicht und stellt keinen Zustand wieder her. Würde eine Ausnahme eine noexcept-Funktion verlassen, wird std::terminate aufgerufen. Der Operator noexcept(expr) prüft ohne Auswertung, ob der Ausdruck potenziell eine Ausnahme auslösen kann.

Voraussetzungen prüfen. std::swap ist nicht bedingungslos ausnahmefrei: Prüfe die gewählte Überladung und ihre Vorbedingungen. Eine flache Kopie mit gemeinsam genutztem veränderlichem Zustand oder ein irreversibler externer Seiteneffekt bei der Vorbereitung kann die starke Garantie verletzen.

Beispiele

#include <iostream>
#include <utility>

struct State {
    int first;
    int second;
};

struct InjectedFailure {};

void update_basic(State& live, bool fail) {
    live.first = 10;
    if (fail) {
        throw InjectedFailure{};
    }
    live.second = 20;
}

void commit(State& live, State& staged) noexcept {
    static_assert(noexcept(std::swap(live, staged)));
    std::swap(live, staged);
}

void update_strong(State& live, bool fail) {
    State staged = live;
    update_basic(staged, fail);
    commit(live, staged);
}

void print(const char* label, const State& state) {
    std::cout << label << ": " << state.first << ' ' << state.second << '\n';
}

int main() {
    State basic{1, 2};
    State strong{1, 2};

    try {
        update_basic(basic, true);
    } catch (const InjectedFailure&) {
        print("basic failure", basic);
    }

    try {
        update_strong(strong, true);
    } catch (const InjectedFailure&) {
        print("strong failure", strong);
    }

    update_strong(strong, false);
    print("strong success", strong);
}

Ergebnis

basic failure: 10 2
strong failure: 1 2
strong success: 10 20

Beide Objekte starten mit `1 2`. Die nach dem ersten Schreibzugriff absichtlich ausgelöste Ausnahme lässt `basic` im gültigen Zustand `10 2`. In `update_strong` ändert sich nur `staged`; `strong` behält daher `1 2`. Ohne absichtlich ausgelöste Ausnahme übernimmt `commit` den Zustand `10 20`.

Zugehörige Lektionen

  • C++ · Lektion 15 · Fortgeschritten · Version: 3

Quellen