std::is_constant_evaluated

constexpr bool is_constant_evaluated() noexcept;

Détecte si l'appel de fonction se produit dans un contexte évalué de manière constante. Retourne true si l'évaluation de l'appel se produit dans l'évaluation d'une expression ou d'une conversion qui est manifestement évaluée de manière constante ; sinon retourne false.

Pour déterminer si les initialisateurs des variables suivantes sont manifestement évalués de manière constante, les compilateurs peuvent d'abord effectuer une évaluation constante d'essai :

• variables de type référence ou de type intégral ou énumération qualifié const ;
• variables static et thread local.

Il n'est pas recommandé de dépendre du résultat dans ce cas.

int y = 0;
const int a = std::is_constant_evaluated() ? y : 1;
// Trial constant evaluation fails. The constant evaluation is discarded.
// Variable a is dynamically initialized with 1

const int b = std::is_constant_evaluated() ? 2 : y;
// Constant evaluation with std::is_constant_evaluated() == true succeeds.
// Variable b is statically initialized with 2

Paramètres

(aucun)

Valeur de retour

true si l'évaluation de l'appel se produit durant l'évaluation d'une expression ou conversion manifestement évaluée de manière constante ; sinon false .

Implémentation possible

// Cette implémentation nécessite C++23 pour if consteval.
constexpr bool is_constant_evaluated() noexcept
{
    if consteval
    {
        return true;
    }
    else 
    {
        return false;
    }
}

Notes

Lorsqu'il est directement utilisé comme condition d'une static_assert ou d'une instruction constexpr if , std :: is_constant_evaluated ( ) retourne toujours true .

Parce que if consteval est absent en C++20, std::is_constant_evaluated est généralement implémenté en utilisant une extension du compilateur.

Exemple

#include <cmath>
#include <iostream>
#include <type_traits>
constexpr double power(double b, int x)
{
    if (std::is_constant_evaluated() && !(b == 0.0 && x < 0))
    {
        // A constant-evaluation context: Use a constexpr-friendly algorithm.
        if (x == 0)
            return 1.0;
        double r {1.0};
        double p {x > 0 ? b : 1.0 / b};
        for (auto u = unsigned(x > 0 ? x : -x); u != 0; u /= 2)
        {
            if (u & 1)
                r *= p;
            p *= p;
        }
        return r;
    }
    else
    {
        // Let the code generator figure it out.
        return std::pow(b, double(x));
    }
}
int main()
{
    // A constant-expression context
    constexpr double kilo = power(10.0, 3);
    int n = 3;
    // Not a constant expression, because n cannot be converted to an rvalue
    // in a constant-expression context
    // Equivalent to std::pow(10.0, double(n))
    double mucho = power(10.0, n);
    std::cout << kilo << " " << mucho << "\n"; // (3)
}

1000 1000

Voir aussi