CKTIS / C++
Výnimková bezpečnosť v C++: základná, silná a no-throw záruka
Základná záruka pripúšťa čiastočnú zmenu platného stavu, silná pri výnimke vylučuje pozorovateľnú zmenu a záruka no-throw nepripustí, aby sa výnimka dostala k volajúcemu.
Verzia: 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)));Základná záruka (basic). Ak výnimka opustí operáciu, nedôjde k úniku prostriedkov a invarianty objektov zahrnutých v kontrakte zostanú zachované. Platný stav nemusí byť pôvodný: prvá z dvoch zmien môže zostať viditeľná, ak druhá vyvolá výnimku.
Silná záruka (strong). Ak výnimka opustí operáciu, stav zahrnutý v kontrakte je pozorovateľne rovnaký ako pred volaním. Úspešná operácia ho môže zmeniť. Pri postupe copy-and-swap vytvoríš nezávislú kópiu a vykonáš na nej zmeny, ktoré môžu vyvolať výnimku. Ak príprava vyvolá výnimku, pôvodný objekt zostane nedotknutý. Až po úspešnej príprave potvrdíš výsledok výmenou, ktorá musí uspieť bez vyvolania výnimky. Dočasný objekt prevezme pôvodný stav a pri svojom zániku ho uvoľní bez vyvolania výnimky.
Záruka no-throw. Ak sú splnené vstupné podmienky, žiadna výnimka sa nedostane k volajúcemu. Operácia môže výnimky zachytiť interne alebo oznámiť zlyhanie inak, napríklad chybovým kódom. Špecifikátor noexcept nekontroluje správnosť implementácie ani neobnovuje stav. Ak by výnimka mala opustiť funkciu noexcept, zavolá sa std::terminate. Operátor noexcept(expr) zisťuje, či výraz môže potenciálne vyvolať výnimku, bez jeho vyhodnotenia.
Over predpoklady. std::swap nie je bez výnimiek za všetkých okolností: over vybrané preťaženie a jeho vstupné podmienky. Plytká kópia so zdieľaným meniteľným stavom alebo nezvratný vonkajší vedľajší účinok počas prípravy môže porušiť silnú záruku.
Prí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ýsledok
basic failure: 10 2 strong failure: 1 2 strong success: 10 20
Oba objekty začínajú v stave `1 2`. Výnimka zámerne vyvolaná po prvom zápise ponechá `basic` v platnom stave `10 2`. V `update_strong` sa zmení iba `staged`, takže `strong` si ponechá `1 2`. Bez vyvolanej výnimky `commit` potvrdí stav `10 20`.
Súvisiace lekcie
- C++ · Lekcia 15 · Pokročilá · Verzia: 3
Zdroje
- 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]