std:: is_constant_evaluated

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

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

• variables avec type référence ou type intégral ou énumération qualifié const ;
• variables statiques et variables locales de thread.

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;
// L'évaluation constante d'essai échoue. L'évaluation constante est rejetée.
// La variable a est initialisée dynamiquement avec 1
const int b = std::is_constant_evaluated() ? 2 : y;
// L'évaluation constante avec std::is_constant_evaluated() == true réussit.
// La variable b est initialisée statiquement avec 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