Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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