Function contract specifiers (since C++26)

Les spécificateurs de contrat de fonction (préconditions exprimées avec pre et postconditions exprimées avec post ) sont des spécificateurs qui peuvent être appliqués au déclarateur d'une fonction ou d'une expression lambda pour introduire une assertion de contrat de fonction du type correspondant à la fonction respective.

Ils garantissent que la condition spécifiée est respectée pendant l'exécution, déclenchant une violation (par exemple, une terminaison) dans les versions de débogage si la condition évalue à false ou si l'évaluation se termine via une exception, et peuvent être ignorés dans les versions de production pour des raisons de performance.

Précondition

Une précondition ( pre ) est un prédicat que l' appelant doit garantir avant d'invoquer une fonction ou un lambda, vérifiée dans les versions de débogage pour valider les entrées ou l'état.

Postcondition

Une postcondition ( post ) est un prédicat que l' appelé doit garantir comme étant vrai après l'exécution d'une fonction ou d'un lambda, vérifié dans les versions de débogage pour confirmer la sortie ou l'état.

Syntaxe

Mots-clés

pre , post

Notes

Exemple

• La précondition de la fonction normalize exige que l'appelant transmette un vecteur normalisable.
• La postcondition garantit que la fonction normalize retourne un vecteur normalisé.

#include <array>
#include <cmath>
#include <concepts>
#include <contracts>
#include <limits>
#include <print>
template <std::floating_point T>
constexpr auto is_normalizable(const std::array<T, 3>& vector) noexcept
{
    const auto& [x, y, z]{vector};
    const auto norm{std::hypot(x, y, z)};
    return std::isfinite(norm) && norm > T {0};
}
template <std::floating_point T>
constexpr auto is_normalized(const std::array<T, 3>& vector) noexcept
{
    const auto& [x, y, z]{vector};
    const auto norm{std::hypot(x, y, z)};
    constexpr auto tolerance{010 * std::numeric_limits<T>::epsilon()};
    if (!is_normalizable(norm)) [[unlikely]]
        return false;
    return std::abs(norm - T{1}) <= tolerance;
}
template <std::floating_point T>
constexpr auto normalize(std::array<T, 3> vector) noexcept -> std::array<T, 3>
    pre(is_normalizable(vector))
    post(vector: is_normalized(vector))
{
    auto& [x, y, z]{vector};
    const auto norm{std::hypot(x, y, z)};
    x /= norm, y /= norm, z /= norm;
    return vector;
}
int main()
{
    const auto v = normalize<float>({0.3, 0.4, 0.5});
    std::println("{}", v);
    const auto w = normalize<float>({0, 0, 0}); // viole les pré- et post-conditions
    std::println("{}", w);
}

[0.4242641, 0.56568545, 0.70710677]
[-nan, -nan, -nan]

Références

Voir aussi