Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Warunki wstępne i niezmienniki dziedzinowe

Odróżnij wymagania wobec wywołującego od reguł poprawnego stanu obiektu. Waliduj dane zewnętrzne niezależnie od `assert` i chroń niezmiennik przez interfejs typu.

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

Składnia

// 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.

Warunek wstępny musi być spełniony przed użyciem operacji; odpowiada za to kod wywołujący. Na przykład limit->get() wymaga, by limit zawierał wartość. Niezmiennik dziedzinowy opisuje poprawny stan obiektu: każdy Limit musi przechowywać liczbę od 1 do 100 włącznie. Konstrukcja ustanawia niezmiennik, a publiczne operacje go zachowują.

W C++23 assert(condition) z <cassert> to makro, nie funkcja std::assert. Gdy jest aktywne, oblicza warunek; jeśli wynik jest zerem (w tym false), wypisuje komunikat diagnostyczny na standardowy strumień błędów i wywołuje std::abort(). Jeśli NDEBUG jest zdefiniowane przy dołączaniu <cassert>, wyrażenie nie jest obliczane. Nie umieszczaj w assert walidacji danych zewnętrznych ani potrzebnych efektów ubocznych.

static_assert to deklaracja sprawdzana podczas kompilacji, niezależnie od NDEBUG. Tutaj sprawdza stałe granice: fałszywy warunek sprawia, że program jest niepoprawny. Nie sprawdza wartości otrzymanej podczas działania programu.

Limit::make sprawdza zakres zwykłym if i zwraca std::nullopt przy odrzuceniu. Publiczny konstruktor bez walidacji lub publiczne pole z możliwością zapisu pozwoliłyby ominąć fabrykę albo zepsuć poprawny obiekt. Prywatny konstruktor przyjmujący liczbę i prywatne pole, którego interfejs nie pozwala dowolnie zmieniać, zamykają te drogi. get() zwraca kopię liczby; jego assert jedynie diagnozuje błąd wewnętrzny.

Przykłady

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

Wynik

0: rejected
42: accepted 42
101: rejected

Liczby `0`, `42` i `101` zastępują już odczytane dane wejściowe. `if (limit)` sprawdza obecność wartości przed użyciem `->`. Oczekiwany wynik jest taki sam z `NDEBUG` i bez niego.

Powiązane lekcje

  • C++ · Lekcja 52 · Zaawansowany · Wersja: 3

Źródła