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

CKTIS / C++

Sécurité face aux exceptions : garanties et copy-and-swap

Les garanties de sécurité face aux exceptions précisent l’état qui subsiste après l’échec d’une opération : un état valide, un état inchangé ou aucune exception propagée. Copy-and-swap peut fournir la garantie forte en préparant une copie avant de valider une modification.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

T& operator=(const T& other) { T temporary(other); swap(temporary); return *this; }
void swap(T& other) noexcept;

La sécurité face aux exceptions décrit le contrat d’une opération, et pas seulement son utilisation de try et catch. La garantie de base (basic guarantee) préserve les invariants des objets et évite les fuites de ressources, mais autorise une modification des valeurs après une exception. La garantie forte (strong guarantee) promet en plus qu’une opération qui échoue n’a aucun effet dans le périmètre de son contrat : elle s’achève entièrement ou laisse cet état inchangé.

La garantie sans exception (no-throw) signifie qu’une opération ne propage pas d’exception. La seule présence de noexcept ne prouve pas que les erreurs sont correctement gérées : une exception qui tente de sortir d’une telle fonction entraîne l’appel de std::terminate, au lieu d’annuler les modifications. Les garanties sont documentées pour chaque opération ; la présence d’un catch ne suffit pas à les assurer.

Copy-and-swap met en œuvre la sécurité forte pour l’affectation : on construit d’abord temporary, puis on valide la modification au moyen d’un swap qui ne lance pas d’exception. Si la copie échoue, la cible n’a pas encore été modifiée. Après l’échange, l’objet temporaire contient l’ancien état et le libère lors de sa destruction. Cette technique exige une copie qui ne modifie pas l’original, un échange qui ne lance pas d’exception et une destruction sûre. Son coût peut comprendre une copie et une allocation supplémentaires ; les effets externes, comme l’écriture dans un fichier, ne sont pas annulés automatiquement.

RAII lie les ressources à la durée de vie des objets : pendant le déroulement de la pile, les objets locaux déjà construits sont détruits. Les destructeurs devraient effectuer le nettoyage sans propager d’exception. Si une exception s’échappe d’un destructeur invoqué dans le cadre du déroulement de la pile, std::terminate est appelé. En revanche, si un destructeur susceptible de lancer une exception est appelé dans le cours normal de l’exécution du code de nettoyage, un catch dans ce même code peut intercepter une exception provenant de ce destructeur, même si le déroulement de la pile dû à l’exception initiale est toujours en cours. La norme exige des destructeurs qui ne lancent pas d’exception dans la bibliothèque standard. Les sources fournies sont un projet de norme évolutif, et non un texte C++23 figé.

Identifiants de référence couverts par cette entrée : Basic, strong and no-throw guarantees; copy-and-swap.

Exemples

#include <iostream>

struct CopyFailure {};

class Value {
    int number_;
public:
    inline static bool fail_copy = false;

    explicit Value(int number) noexcept : number_(number) {}

    Value(const Value& other) : number_(other.number_) {
        if (fail_copy) throw CopyFailure{};
    }

    void swap(Value& other) noexcept {
        int old = number_;
        number_ = other.number_;
        other.number_ = old;
    }

    Value& operator=(const Value& other) {
        Value temporary(other);
        swap(temporary);
        return *this;
    }

    int get() const noexcept { return number_; }
};

int main() {
    Value target(7), source(42);
    Value::fail_copy = true;
    try {
        target = source;
    } catch (const CopyFailure&) {
        std::cout << "after failure: " << target.get() << '\n';
    }
    Value::fail_copy = false;
    target = source;
    std::cout << "after success: " << target.get() << '\n';
}

Résultat

after failure: 7
after success: 42

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources