Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

Výjimková bezpečnost v C++: základní, silná a no-throw záruka

Základní záruka připouští částečnou změnu platného stavu; silná při výjimce vylučuje pozorovatelnou změnu a záruka no-throw nepřipustí, aby výjimka doputovala k volajícímu.

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

Syntaxe

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

Základní záruka (basic). Pokud výjimka opustí operaci, nedojde k úniku prostředků a invarianty objektů zahrnutých do kontraktu zůstanou zachovány. Platný stav nemusí být původní: první ze dvou změn může zůstat viditelná, pokud druhá vyvolá výjimku.

Silná záruka (strong). Pokud výjimka opustí operaci, je stav zahrnutý do kontraktu pozorovatelně stejný jako před voláním. Úspěšná operace jej může změnit. Při použití copy-and-swap vytvoříš nezávislou kopii a provedeš na ní změny, které mohou vyvolat výjimku. Pokud příprava vyvolá výjimku, původní objekt zůstane nedotčený. Teprve po úspěšné přípravě potvrdíš výsledek výměnou, která musí proběhnout úspěšně a bez výjimky. Dočasný objekt převezme starý stav a při svém zániku jej uvolní bez vyvolání výjimky.

Záruka no-throw. Jsou-li splněny vstupní podmínky, žádná výjimka se nedostane k volajícímu. Operace může výjimku zachytit uvnitř nebo oznámit selhání jinak, například chybovým kódem. Specifikátor noexcept nekontroluje správnost implementace ani neobnovuje stav. Pokud by výjimka měla opustit funkci noexcept, zavolá se std::terminate. Operátor noexcept(expr) zjišťuje, zda je výraz potenciálně vyhazující, aniž by ho vyhodnotil.

Ověř předpoklady. std::swap není bez výjimek za všech okolností: ověř vybrané přetížení a jeho vstupní podmínky. Mělká kopie se sdíleným měnitelným stavem nebo nevratný vnější vedlejší účinek při přípravě může silnou záruku porušit.

Příklady

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

Výsledek

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

Oba objekty začínají ve stavu `1 2`. Výjimka záměrně vyvolaná po prvním zápisu ponechá `basic` v platném stavu `10 2`. V `update_strong` se změní jen `staged`, takže `strong` si zachová `1 2`. Bez vyvolané výjimky `commit` potvrdí stav `10 20`.

Související lekce

  • C++ · Lekce 15 · Pokročilá · Verze: 3

Zdroje