Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Precondizioni e invarianti di dominio

Distingui gli obblighi di chi chiama dalle regole sullo stato valido. Convalida gli input esterni senza dipendere da `assert` e preserva l’invariante tramite l’interfaccia pubblica.

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

Sintassi

// ISO C++23: assert is a macro, not std::assert.
#include <cassert>
assert(condition);
static_assert(constant_condition);
static_assert(constant_condition, "message");

// To disable assert, define NDEBUG before including <cassert>.
// Preconditions and domain invariants are design rules, not C++23 declarations.

Una precondizione deve essere soddisfatta prima di usare un’operazione; è responsabilità di chi la chiama. Per esempio, limit->get() richiede che limit contenga un valore. Un invariante di dominio descrive uno stato valido: ogni Limit deve contenere un numero da 1 a 100, estremi inclusi. La costruzione stabilisce l’invariante e le operazioni pubbliche lo preservano.

In C++23, assert(condition) di <cassert> è una macro, non una funzione std::assert. Se è attiva, valuta la condizione; se il risultato è zero (incluso false), scrive un messaggio diagnostico sullo standard error e chiama std::abort(). Se NDEBUG è definita quando si include <cassert>, l’espressione non viene valutata. Non inserire in assert né la convalida degli input esterni né effetti collaterali necessari.

static_assert è una dichiarazione controllata in fase di compilazione, indipendentemente da NDEBUG. Qui verifica gli estremi costanti: se la condizione è falsa, il programma è mal formato. Non verifica un valore ricevuto durante l’esecuzione.

Limit::make controlla l’intervallo con un normale if e restituisce std::nullopt se rifiuta l’input. Un costruttore pubblico senza convalida o un campo pubblico modificabile permetterebbero di aggirare la funzione factory o rendere non valido un oggetto valido. Il costruttore privato che riceve un intero e il campo privato a cui l’interfaccia non permette di assegnare valori arbitrari chiudono queste due vie. get() restituisce una copia del numero; il suo assert serve solo a diagnosticare un errore interno.

Esempi

#include <cassert>
#include <iostream>
#include <optional>

class Limit {
    static constexpr int min_value = 1;
    static constexpr int max_value = 100;
    static_assert(min_value <= max_value);

    int value_;
    explicit Limit(int value) noexcept : value_(value) {}

    static constexpr bool in_range(int value) noexcept {
        return min_value <= value && value <= max_value;
    }

public:
    static std::optional<Limit> make(int value) noexcept {
        if (!in_range(value)) {
            return std::nullopt;
        }
        return Limit{value};
    }

    int get() const noexcept {
        assert(in_range(value_));
        return value_;
    }
};

void report(int input) {
    const auto limit = Limit::make(input);
    if (limit) {
        std::cout << input << ": accepted " << limit->get() << '\n';
    } else {
        std::cout << input << ": rejected\n";
    }
}

int main() {
    report(0);
    report(42);
    report(101);
}

Risultato

0: rejected
42: accepted 42
101: rejected

Gli interi `0`, `42` e `101` rappresentano input già letti. `if (limit)` verifica la presenza di un valore prima di usare `->`. L’output atteso è identico con e senza `NDEBUG`.

Lezioni correlate

  • C++ · Lezione 52 · Avanzato · Versione: 3

Fonti