NAME¶

std::is_constant_evaluated - std::is_constant_evaluated

Synopsis¶

Defined in header <type_traits>
constexpr bool is_constant_evaluated() noexcept; (since C++20)

Detects whether the function call occurs within a constant-evaluated context.
Returns true if the evaluation of the call occurs within the evaluation of an
expression or conversion that is manifestly constant-evaluated; otherwise returns
false.

To determine whether initializers of following variables are manifestly
constant-evaluated, compilers may first perform a trial constant evaluation:

* variables with reference type or const-qualified integral or enumeration type;
* static and thread local variables.

It is not recommended to depend on the result in this case.

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

Parameters¶

(none)

Return value¶

true if the evaluation of the call occurs within the evaluation of an expression or
conversion that is manifestly constant-evaluated; otherwise false.

Possible implementation¶

// This implementation requires C++23 if consteval.
constexpr bool is_constant_evaluated() noexcept
{
if consteval
{
return true;
}
else
{
return false;
}
}

Notes¶

When directly used as the condition of static_assert declaration or constexpr if
statement, std::is_constant_evaluated() always returns true.

Because if consteval is absent in C++20, std::is_constant_evaluated is typically
implemented using a compiler extension.

Feature-test macro Value Std Feature
__cpp_lib_is_constant_evaluated 201811L (C++20) std::is_constant_evaluated

Example¶

// Run this code

#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)
}

Output:¶

1000 1000

See also¶

constexpr specifier(C++11) specifies that the value of a variable or function can be
computed at compile time
specifies that a function is an immediate function, that
consteval specifier(C++20) is, every call to the function must be in a constant
evaluation
constinit specifier(C++20) asserts that a variable has static initialization, i.e.
zero initialization and constant initialization