Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Sûreté vis-à-vis des exceptions en C++ : garanties de base, forte et no-throw

La garantie de base autorise un changement partiel si l’état reste valide ; la garantie forte exclut tout changement observable après une exception ; la garantie no-throw empêche la propagation à l’appelant.

Version : ISO C++23; implementation support may vary

Syntaxe

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

Garantie de base (basic). Si une exception sort de l’opération, aucune ressource ne fuit et les invariants des objets couverts par le contrat restent satisfaits. Un état valide n’est pas forcément inchangé : la première de deux mises à jour peut rester visible si la seconde lève une exception.

Garantie forte (strong). Si une exception sort de l’opération, l’état couvert par le contrat est, du point de vue observable, identique à celui d’avant l’appel. En cas de succès, l’état peut changer. Avec copy-and-swap, on crée une copie indépendante et on y effectue les modifications susceptibles de lever une exception. Si la préparation lève une exception, l’original reste intact. Une fois la préparation réussie, on valide le résultat par un échange qui doit réussir sans lever d’exception. L’objet temporaire récupère l’ancien état et le libère lors de sa destruction, sans lever d’exception.

Garantie no-throw. Si les préconditions sont remplies, aucune exception ne parvient à l’appelant. L’opération peut intercepter des exceptions en interne ou signaler un échec autrement, par exemple par un code d’erreur. Le spécificateur noexcept ne vérifie pas l’implémentation et ne restaure pas l’état. Si une exception tente de sortir d’une fonction noexcept, std::terminate est appelé. L’opérateur noexcept(expr) détermine si l’expression est potentiellement susceptible de lever une exception sans l’évaluer.

Vérifier les hypothèses. std::swap n’est pas inconditionnellement non levant : vérifier la surcharge sélectionnée et ses préconditions. Une copie superficielle qui partage un état mutable ou un effet externe irréversible pendant la préparation peut rompre la garantie forte.

Exemples

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

Résultat

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

Les deux objets commencent à `1 2`. L’exception déclenchée après la première écriture laisse `basic` dans l’état valide `10 2`. Dans `update_strong`, seul `staged` change ; `strong` conserve donc `1 2`. Sans exception déclenchée, `commit` applique `10 20`.

Leçons associées

  • C++ · Leçon 15 · Avancé · Version : 3

Sources