Function contract specifiers (since C++26)

Funktionsvertragsspezifizierer (Vorbedingungen gekennzeichnet mit pre und Nachbedingungen gekennzeichnet mit post ) sind Spezifizierer, die auf den Deklarator einer Funktion oder eines Lambda-Ausdrucks angewendet werden können, um eine Funktionsvertragsassertion der jeweiligen Art in die entsprechende Funktion einzuführen.

Sie stellen sicher, dass die angegebene Bedingung während der Ausführung erfüllt ist, und lösen eine Verletzung (z.B. Abbruch) in Debug-Builds aus, falls die Bedingung zu false ausgewertet wird oder die Auswertung über eine Exception beendet wird, und können in Release-Builds aus Performance-Gründen ignoriert werden.

Vorbedingung

Eine Vorbedingung ( pre ) ist ein Prädikat, das der Aufrufer sicherstellen muss, bevor er eine Funktion oder Lambda aufruft, geprüft in Debug-Builds zur Validierung von Eingaben oder Zuständen.

Postbedingung

Eine Nachbedingung ( post ) ist ein Prädikat, das der Aufgerufene sicherstellen muss, das nach dem Abschluss einer Funktion oder eines Lambdas gilt, überprüft in Debug-Builds zur Bestätigung der Ausgabe oder des Zustands.

Syntax

Schlüsselwörter

pre , post

Hinweise

Beispiel

• Die Vorbedingung der Funktion normalize erfordert, dass der Aufrufer einen normalisierbaren Vektor übergibt.
• Die Nachbedingung stellt sicher, dass die Funktion normalize einen normalisierten Vektor zurückgibt.

#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}); // verletzt Vorbedingungen und Nachbedingungen
    std::println("{}", w);
}

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

Referenzen

Siehe auch