KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Precondities en domeininvarianten

Maak onderscheid tussen wat de aanroeper moet garanderen en wat een geldige objecttoestand is. Valideer externe invoer zonder `assert` en bewaak de invariant via de publieke interface.

Versie: 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.

Een preconditie moet gelden voordat een bewerking wordt gebruikt; de aanroeper moet daarvoor zorgen. Zo vereist limit->get() dat limit een waarde bevat. Een domeininvariant beschrijft een geldige objecttoestand: elk Limit-object moet een getal van 1 tot en met 100 opslaan. De constructie brengt het object in een geldige toestand en publieke bewerkingen houden de invariant in stand.

In C++23 is assert(condition) uit <cassert> een macro, geen functie std::assert. Als de macro actief is, evalueert hij de voorwaarde. Is het resultaat nul (ook bij false), dan schrijft hij een diagnostische melding naar de standaardfoutuitvoer en roept hij std::abort() aan. Als NDEBUG gedefinieerd is wanneer <cassert> wordt opgenomen, wordt de expressie niet geëvalueerd. Zet validatie van externe invoer en noodzakelijke neveneffecten niet in assert.

static_assert is een declaratie die tijdens het compileren wordt gecontroleerd, ongeacht NDEBUG. Hier controleert die de constante grenzen: een onware voorwaarde maakt het programma ongeldig. Een waarde die pas tijdens de uitvoering binnenkomt, wordt er niet mee gecontroleerd.

Limit::make controleert het bereik met een gewone if en geeft bij afwijzing std::nullopt terug. Met een publieke constructor zonder validatie of een beschrijfbaar publiek veld kun je de fabrieksfunctie omzeilen of een geldig object ongeldig maken. De private constructor die een geheel getal neemt en het private veld dat via de interface niet willekeurig kan worden gewijzigd, sluiten die routes af. get() geeft een kopie van het getal terug; de assert daarin dient alleen om een interne fout te signaleren.

Voorbeelden

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

Resultaat

0: rejected
42: accepted 42
101: rejected

De gehele getallen `0`, `42` en `101` stellen reeds ingelezen invoer voor. `if (limit)` controleert of er een waarde is voordat `->` wordt gebruikt. De verwachte uitvoer is met en zonder `NDEBUG` gelijk.

Gerelateerde lessen

  • C++ · Les 52 · Gevorderd · Versie: 3

Bronnen