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
- WG21 P0208R0: Copy-Swap Helper (Motivation)
- WG21 N4950: Working Draft, Standard for Programming Language C++
- C++ working draft: Exception specifications [except.spec]
- C++ working draft: The std::terminate function [except.terminate]
- C++ working draft: noexcept operator [expr.unary.noexcept]
- C++ working draft: swap [utility.swap]