std::is_constant_evaluated

constexpr bool is_constant_evaluated() noexcept;

Detecta si la llamada a la función ocurre dentro de un contexto de evaluación constante. Devuelve true si la evaluación de la llamada ocurre dentro de la evaluación de una expresión o conversión que es manifiestamente evaluada de forma constante; de lo contrario, devuelve false.

Para determinar si los inicializadores de las siguientes variables son manifiestamente evaluados de forma constante, los compiladores pueden realizar primero una evaluación constante de prueba:

• variables con tipo de referencia o tipo integral o de enumeración calificado como const;
• variables static y thread local.

No se recomienda depender del resultado en este caso.

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

Parámetros

(ninguno)

Valor de retorno

true si la evaluación de la llamada ocurre dentro de la evaluación de una expresión o conversión que es manifiestamente constante-evaluada; de lo contrario false .

Implementación posible

// Esta implementación requiere C++23 if consteval.
constexpr bool is_constant_evaluated() noexcept
{
    if consteval
    {
        return true;
    }
    else 
    {
        return false;
    }
}

Notas

Cuando se utiliza directamente como condición de static_assert o de sentencia constexpr if , std :: is_constant_evaluated ( ) siempre devuelve true .

Debido a que if consteval está ausente en C++20, std::is_constant_evaluated normalmente se implementa usando una extensión del compilador.

Ejemplo

#include <cmath>
#include <iostream>
#include <type_traits>
constexpr double power(double b, int x)
{
    if (std::is_constant_evaluated() && !(b == 0.0 && x < 0))
    {
        // Un contexto de evaluación constante: usar un algoritmo compatible con constexpr
        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
    {
        // Dejar que el generador de código lo resuelva
        return std::pow(b, double(x));
    }
}
int main()
{
    // Un contexto de expresión constante
    constexpr double kilo = power(10.0, 3);
    int n = 3;
    // No es una expresión constante, porque n no puede convertirse a un valor r
    // en un contexto de expresión constante
    // Equivalente a std::pow(10.0, double(n))
    double mucho = power(10.0, n);
    std::cout << kilo << " " << mucho << "\n"; // (3)
}

1000 1000

Véase también