Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

Pré-condições e invariantes de domínio

Distingue as obrigações do código que chama das regras de um estado válido. Valida dados externos sem depender de `assert` e preserva o invariante através da interface pública.

Versão: ISO C++23; implementation support may vary

Sintaxe

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

Uma pré-condição tem de ser satisfeita antes de usar uma operação; cabe ao código que a chama garanti-lo. Por exemplo, limit->get() exige que limit contenha um valor. Um invariante de domínio descreve um estado válido: cada Limit tem de guardar um número de 1 a 100, inclusive. A construção estabelece o invariante e as operações públicas preservam-no.

Em C++23, assert(condition) de <cassert> é uma macro, não uma função std::assert. Quando está ativa, avalia a condição; se o resultado for zero (incluindo false), escreve uma mensagem de diagnóstico na saída de erro padrão e chama std::abort(). Se NDEBUG estiver definida ao incluir <cassert>, a expressão não é avaliada. Não coloques em assert nem a validação de dados externos nem efeitos secundários necessários.

static_assert é uma declaração verificada durante a compilação, independentemente de NDEBUG. Aqui verifica os limites constantes: se a condição for falsa, o programa fica mal formado. Não verifica um valor recebido durante a execução.

Limit::make verifica o intervalo com um if normal e devolve std::nullopt se rejeitar o valor. Um construtor público sem validação ou um campo público modificável permitiriam contornar a função de criação ou invalidar um objeto válido. O construtor privado que recebe um inteiro e o campo privado ao qual a interface não permite atribuir valores arbitrários impedem essas duas situações. get() devolve uma cópia do número; o seu assert serve apenas para diagnosticar um erro interno.

Exemplos

#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

Os inteiros `0`, `42` e `101` representam dados de entrada já lidos. `if (limit)` verifica se existe um valor antes de usar `->`. A saída esperada é igual com e sem `NDEBUG`.

Lições relacionadas

  • C++ · Lição 52 · Avançado · Versão: 3

Fontes