Function contract specifiers (since C++26)

Los especificadores de contrato de función (precondiciones escritas con pre y postcondiciones escritas con post ) son especificadores que pueden aplicarse al declarador de una función o de una expresión lambda para introducir una aserción de contrato de función del tipo correspondiente a la función respectiva.

Garantizan que la condición especificada se mantenga durante la ejecución, activando una violación (por ejemplo, terminación) en compilaciones de depuración si la condición se evalúa como false o la evaluación finaliza mediante una excepción, y pueden ignorarse en compilaciones de lanzamiento por rendimiento.

Precondición

Una precondición ( pre ) es un predicado que el llamador debe garantizar que se cumple antes de invocar una función o lambda, verificada en compilaciones de depuración para validar entradas o estado.

Postcondición

Una postcondición ( post ) es un predicado que el callee debe garantizar que se cumple después de que una función o lambda finalice, verificado en builds de depuración para confirmar la salida o el estado.

Sintaxis

Palabras clave

pre , post

Notas

Ejemplo

• La precondición de la función normalize requiere que el llamador pase un vector normalizable.
• La postcondición asegura que la función normalize retorna un vector normalizado.

#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}); // viola las condiciones pre y post
    std::println("{}", w);
}

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

Referencias

Véase también