WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Vorbedingungen und fachliche Invarianten

Unterscheide Pflichten des Aufrufers von Regeln für gültige Objektzustände. Prüfe externe Eingaben unabhängig von `assert` und sichere die Invariante über die öffentliche Schnittstelle.

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

Syntax

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

Eine Vorbedingung muss vor der Verwendung einer Operation erfüllt sein; dafür ist der aufrufende Code verantwortlich. limit->get() setzt zum Beispiel voraus, dass limit einen Wert enthält. Eine fachliche Invariante beschreibt einen gültigen Objektzustand: Jedes Limit muss eine Zahl von 1 bis einschließlich 100 speichern. Die Konstruktion stellt die Invariante her, öffentliche Operationen erhalten sie.

In C++23 ist assert(condition) aus <cassert> ein Makro, keine Funktion std::assert. Ist es aktiv, wertet es die Bedingung aus. Bei einem Ergebnis von null (auch false) schreibt es eine Diagnose auf die Standardfehlerausgabe und ruft std::abort() auf. Ist NDEBUG beim Einbinden von <cassert> definiert, wird der Ausdruck nicht ausgewertet. Prüfungen externer Eingaben und notwendige Seiteneffekte gehören nicht in assert.

static_assert ist eine Deklaration, die beim Kompilieren geprüft wird und von NDEBUG unabhängig ist. Hier prüft sie die konstanten Grenzen: Eine falsche Bedingung macht das Programm nicht wohlgeformt. Einen erst zur Laufzeit erhaltenen Wert prüft sie nicht.

Limit::make prüft den Bereich mit einem gewöhnlichen if und gibt bei Ablehnung std::nullopt zurück. Ein ungeprüfter öffentlicher Konstruktor oder ein beschreibbares öffentliches Feld würde es erlauben, die Fabrikfunktion zu umgehen oder ein gültiges Objekt ungültig zu machen. Der private Konstruktor mit Ganzzahlparameter und das private Feld ohne öffentliche Schreibmöglichkeit für beliebige Werte schließen diese Wege. get() gibt eine Kopie der Zahl zurück; sein assert dient nur der Diagnose eines internen Fehlers.

Beispiele

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

Ergebnis

0: rejected
42: accepted 42
101: rejected

Die Ganzzahlen `0`, `42` und `101` stehen für bereits eingelesene Eingaben. `if (limit)` prüft vor der Verwendung von `->`, ob ein Wert vorhanden ist. Die erwartete Ausgabe ist mit und ohne `NDEBUG` gleich.

Zugehörige Lektionen

  • C++ · Lektion 52 · Fortgeschritten · Version: 3

Quellen