Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Precondiciones e invariantes de dominio

Distingue las obligaciones de quien llama de las reglas del estado válido. Valida las entradas externas sin depender de `assert` y preserva el invariante mediante la interfaz pública.

Versión: ISO C++23; implementation support may vary

Sintaxis

// 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 precondición debe cumplirse antes de usar una operación; es responsabilidad de quien la llama. Por ejemplo, limit->get() exige que limit contenga un valor. Un invariante de dominio describe un estado válido: cada Limit debe almacenar un número del 1 al 100, ambos incluidos. La construcción establece el invariante y las operaciones públicas lo preservan.

En C++23, assert(condition) de <cassert> es una macro, no una función std::assert. Si está activa, evalúa la condición; si el resultado es cero (incluido false), escribe un diagnóstico en la salida de error estándar y llama a std::abort(). Si NDEBUG está definido al incluir <cassert>, la expresión no se evalúa. No pongas en assert ni la validación de entradas externas ni efectos secundarios necesarios.

static_assert es una declaración que se comprueba durante la compilación y no depende de NDEBUG. Aquí comprueba los límites constantes: si la condición es falsa, el programa está mal formado. No comprueba un valor recibido en tiempo de ejecución.

Limit::make comprueba el intervalo con un if normal y devuelve std::nullopt si rechaza la entrada. Un constructor público sin validación o un campo público modificable permitirían eludir la función de fábrica o invalidar un objeto válido. El constructor privado que recibe un entero y el campo privado que la interfaz no permite modificar arbitrariamente cierran esas vías. get() devuelve una copia del número; su assert solo sirve para diagnosticar un fallo interno.

Ejemplos

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

Resultado

0: rejected
42: accepted 42
101: rejected

Los enteros `0`, `42` y `101` representan entradas ya leídas. `if (limit)` comprueba que hay un valor antes de usar `->`. La salida esperada es la misma con y sin `NDEBUG`.

Lecciones relacionadas

  • C++ · Lección 52 · Avanzado · Versión: 3

Fuentes