Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Sicurezza rispetto alle eccezioni: garanzie e copy-and-swap

Le garanzie di sicurezza rispetto alle eccezioni specificano quale stato rimane dopo il fallimento di un’operazione: uno stato valido, uno invariato oppure nessuna eccezione propagata. Copy-and-swap può offrire la garanzia forte preparando una copia prima di confermare una modifica.

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

Sintassi

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

La sicurezza rispetto alle eccezioni descrive il contratto di un’operazione, non il semplice uso di try e catch. La garanzia di base (basic guarantee) mantiene gli invarianti degli oggetti e impedisce perdite di risorse, ma consente ai valori di cambiare dopo un’eccezione. La garanzia forte (strong guarantee) promette inoltre che un’operazione non riuscita non produce effetti nell’ambito del proprio contratto: o si completa interamente oppure lascia quello stato invariato.

La garanzia no-throw significa che un’operazione non propaga eccezioni. La sola presenza di noexcept non dimostra una corretta gestione degli errori: se un’eccezione tenta di uscire da una funzione del genere, viene chiamato std::terminate invece di annullare le modifiche. Le garanzie si documentano per ogni operazione; la presenza di un catch non basta a garantirle.

Copy-and-swap realizza la sicurezza forte per l’assegnazione: prima costruisce temporary, poi conferma la modifica tramite uno swap che non genera eccezioni. Se la copia fallisce, l’oggetto di destinazione non è ancora stato modificato. Dopo lo scambio, l’oggetto temporaneo contiene lo stato precedente e lo libera quando viene distrutto. La tecnica richiede una copia che non modifichi l’originale, uno scambio senza eccezioni e una distruzione sicura. Il costo può includere una copia e un’allocazione aggiuntive; gli effetti esterni, come la scrittura su file, non vengono annullati automaticamente.

RAII lega le risorse alla durata degli oggetti: durante lo svolgimento dello stack vengono distrutti gli oggetti locali già costruiti. I distruttori dovrebbero eseguire la pulizia senza propagare eccezioni. Se un’eccezione esce da un distruttore invocato nell’ambito dello svolgimento dello stack, viene chiamato std::terminate. Se invece un distruttore potenzialmente in grado di lanciare eccezioni viene chiamato nel normale flusso di esecuzione del codice di pulizia, un catch nello stesso codice può intercettare un’eccezione proveniente da quel distruttore, anche mentre è ancora in corso lo svolgimento dello stack dovuto all’eccezione originale. Lo standard richiede distruttori senza eccezioni nella libreria standard. Le fonti fornite sono una bozza di standard in continuo aggiornamento, non un testo C++23 congelato.

Identificatori di riferimento trattati in questa voce: Basic, strong and no-throw guarantees; copy-and-swap.

Esempi

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

Risultato

after failure: 7
after success: 42

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti