KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Exceptieveiligheid in C++: basisgarantie, sterke garantie en no-throw

De basisgarantie staat gedeeltelijke wijzigingen toe zolang de toestand geldig blijft. De sterke garantie laat bij een exceptie geen waarneembare wijziging achter. Bij no-throw bereikt geen exceptie de aanroeper.

Versie: 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)));

Basisgarantie (basic). Als een exceptie uit de bewerking ontsnapt, lekken er geen resources en blijven de invarianten van de objecten onder het contract geldig. Geldig betekent niet ongewijzigd: de eerste van twee wijzigingen kan zichtbaar blijven als de tweede een exceptie werpt.

Sterke garantie (strong). Als een exceptie uit de bewerking ontsnapt, is de toestand onder het contract waarneembaar gelijk aan die van vóór de aanroep. Bij succes mag de toestand wel veranderen. Met copy-and-swap maak je een onafhankelijke kopie en voer je daarop alle wijzigingen uit die een exceptie kunnen werpen. Als de voorbereiding een exceptie werpt, blijft het origineel intact. Pas na geslaagde voorbereiding leg je het resultaat vast met een verwisseling die moet slagen zonder een exceptie te werpen. Het tijdelijke object neemt de oude toestand over en geeft die bij vernietiging vrij zonder een exceptie te werpen.

No-throw-garantie. Als aan de precondities is voldaan, bereikt geen exceptie de aanroeper. De bewerking kan excepties intern opvangen of een fout op een andere manier melden, bijvoorbeeld met een foutcode. De specifier noexcept controleert de implementatie niet en herstelt geen toestand. Als een exceptie uit een noexcept-functie dreigt te ontsnappen, wordt std::terminate aangeroepen. De operator noexcept(expr) bepaalt zonder evaluatie of de expressie potentieel een exceptie kan werpen.

Controleer de aannames. std::swap is niet onvoorwaardelijk exceptievrij: controleer de gekozen overload en de bijbehorende precondities. Een oppervlakkige kopie die wijzigbare toestand deelt of een onomkeerbaar extern neveneffect tijdens de voorbereiding kan de sterke garantie doorbreken.

Voorbeelden

#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);
}

Resultaat

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

Beide objecten starten op `1 2`. De opzettelijk opgewekte exceptie na de eerste schrijfactie laat `basic` in de geldige toestand `10 2`. In `update_strong` verandert alleen `staged`, dus `strong` behoudt `1 2`. Zonder opgewekte exceptie legt `commit` de toestand `10 20` vast.

Gerelateerde lessen

  • C++ · Les 15 · Gevorderd · Versie: 3

Bronnen