CKTIS / C++
Préconditions et invariants du domaine
Distinguez les obligations de l’appelant des règles qui définissent un état valide. Validez les entrées externes sans `assert` et faites préserver l’invariant par l’interface publique.
Version : ISO C++23; implementation support may vary
Syntaxe
// 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.Une précondition doit être remplie avant d’utiliser une opération : c’est à l’appelant de s’en assurer. Par exemple, limit->get() exige que limit contienne une valeur. Un invariant du domaine décrit un état valide : tout Limit doit stocker un nombre de 1 à 100 inclus. La construction établit l’invariant et les opérations publiques le préservent.
En C++23, assert(condition), fourni par <cassert>, est une macro, pas une fonction std::assert. Lorsqu’elle est active, elle évalue la condition. Si le résultat vaut zéro (y compris false), elle écrit un diagnostic sur la sortie d’erreur standard et appelle std::abort(). Si NDEBUG est défini lors de l’inclusion de <cassert>, l’expression n’est pas évaluée. Ne placez dans assert ni validation des entrées externes ni effets de bord nécessaires.
static_assert est une déclaration vérifiée à la compilation, indépendamment de NDEBUG. Ici, elle vérifie les bornes constantes : si la condition est fausse, le programme est mal formé. Elle ne vérifie pas une valeur reçue à l’exécution.
Limit::make vérifie l’intervalle avec un if ordinaire et renvoie std::nullopt en cas de rejet. Un constructeur public sans validation ou un champ public modifiable permettrait de contourner la fonction de création ou de rendre un objet valide invalide. Le constructeur privé qui reçoit un entier et le champ privé auquel l’interface ne permet pas d’attribuer une valeur arbitraire ferment ces deux voies. get() renvoie une copie du nombre ; son assert sert uniquement à diagnostiquer un bogue interne.
Exemples
#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);
}Résultat
0: rejected 42: accepted 42 101: rejected
Les entiers `0`, `42` et `101` représentent des entrées déjà lues. `if (limit)` vérifie qu’une valeur est présente avant d’utiliser `->`. La sortie attendue est identique avec ou sans `NDEBUG`.
Leçons associées
- C++ · Leçon 52 · Avancé · Version : 3