CKTIS / C++
Sicurezza rispetto alle eccezioni in C++: garanzie di base, forte e no-throw
La garanzia di base ammette modifiche parziali purché lo stato resti valido; quella forte esclude modifiche osservabili dopo un’eccezione, mentre la no-throw impedisce eccezioni verso il chiamante.
Versione: ISO C++23; implementation support may vary
Sintassi
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)));Garanzia di base (basic). Se un’eccezione esce dall’operazione, non si perdono risorse e restano validi gli invarianti degli oggetti coperti dal contratto. Valido non significa invariato: il primo di due aggiornamenti può rimanere visibile se il secondo lancia un’eccezione.
Garanzia forte (strong). Se un’eccezione esce dall’operazione, lo stato coperto dal contratto è osservabilmente identico a quello precedente alla chiamata. In caso di successo lo stato può cambiare. Con copy-and-swap si crea una copia indipendente e si eseguono su di essa le modifiche che possono lanciare eccezioni. Se la preparazione lancia un’eccezione, l’originale resta intatto. Solo dopo che la preparazione è riuscita si conferma il risultato con uno scambio che deve riuscire senza lanciare eccezioni. L’oggetto temporaneo prende in carico lo stato precedente e lo rilascia alla distruzione senza lanciare eccezioni.
Garanzia no-throw. Se si rispettano le precondizioni, nessuna eccezione raggiunge il chiamante. L’operazione può intercettare eccezioni internamente o segnalare un errore in altro modo, per esempio con un codice di errore. Lo specificatore noexcept non convalida l’implementazione e non ripristina lo stato. Se un’eccezione tenta di uscire da una funzione noexcept, viene invocato std::terminate. L’operatore noexcept(expr) verifica se l’espressione può potenzialmente lanciare un’eccezione senza valutarla.
Controlla le ipotesi. std::swap non è sempre esente da eccezioni: controlla l’overload selezionato e le sue precondizioni. Una copia superficiale che condivide stato mutabile o un effetto esterno irreversibile durante la preparazione può compromettere la garanzia forte.
Esempi
#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);
}
Risultato
basic failure: 10 2 strong failure: 1 2 strong success: 10 20
Entrambi gli oggetti partono da `1 2`. L’eccezione provocata dopo la prima scrittura lascia `basic` nello stato valido `10 2`. In `update_strong` cambia solo `staged`, perciò `strong` conserva `1 2`. Se non si provoca l’eccezione, `commit` applica `10 20`.
Lezioni correlate
- C++ · Lezione 15 · Avanzato · Versione: 3
Fonti
- 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]