Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C++

Varnost ob izjemah v C++: osnovno in močno jamstvo ter jamstvo no-throw

Osnovno jamstvo dopušča delne spremembe, če stanje ostane veljavno. Močno jamstvo ob izjemi izključuje opazne spremembe, jamstvo no-throw pa preprečuje širjenje izjem do klicatelja.

Različica: ISO C++23; implementation support may vary

Sintaksa

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

Osnovno jamstvo (basic). Če se izjema razširi iz operacije, viri ne uhajajo, invariante objektov, ki jih zajema pogodba, pa ostanejo veljavne. Veljavno ne pomeni nespremenjeno: prva od dveh sprememb lahko ostane vidna, če druga sproži izjemo.

Močno jamstvo (strong). Če se izjema razširi iz operacije, je stanje, ki ga zajema pogodba, z vidika opazovalca enako kot pred klicem. Ob uspehu se stanje lahko spremeni. Pri vzorcu copy-and-swap najprej ustvariš neodvisno kopijo, nato na njej izvedeš spremembe, ki lahko sprožijo izjemo. Če priprava sproži izjemo, izvirnik ostane nedotaknjen. Šele po uspešni pripravi potrdiš rezultat z zamenjavo, ki mora uspeti brez izjeme. Začasni objekt prevzame staro stanje in ga ob uničenju sprosti, ne da bi sprožil izjemo.

Jamstvo no-throw. Če so predpogoji izpolnjeni, nobena izjema ne doseže klicatelja. Operacija lahko izjemo prestreže znotraj sebe ali napako sporoči drugače, denimo s kodo napake. Specifikator noexcept ne preverja pravilnosti implementacije in ne obnovi stanja. Če bi se izjema razširila iz funkcije noexcept, se pokliče std::terminate. Operator noexcept(expr) preveri, ali izraz potencialno lahko sproži izjemo, ne da bi ga ovrednotil.

Preveri predpostavke. std::swap ni brez izjem v vseh primerih: preveri izbrano preobremenitev in njene predpogoje. Plitva kopija, ki si deli spremenljivo stanje, ali nepovraten zunanji stranski učinek med pripravo lahko krši močno jamstvo.

Primeri

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

Rezultat

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

Oba objekta začneta v stanju `1 2`. Izjema, namerno sprožena po prvem zapisu, pusti `basic` v veljavnem stanju `10 2`. V `update_strong` se spremeni samo `staged`, zato `strong` ohrani `1 2`. Če izjema ni sprožena, `commit` potrdi stanje `10 20`.

Povezane lekcije

  • C++ · Lekcija 15 · Napredna · Različica: 3

Viri