< cpp‎ | types
Utilities library
General utilities
Relational operators (deprecated in C++20)
Integer comparison functions
Swap and type operations
Common vocabulary types

Elementary string conversions
Type support
Basic types
Fundamental types
Fixed width integer types (C++11)
Numeric limits
C numeric limits interface
Runtime type information
Type traits
Type categories
Type properties
(C++11)(until C++20)
(C++11)(deprecated in C++20)
Type trait constants
Constant evaluation context
Supported operations
Relationships and property queries
Type modifications
Type transformations
(C++11)(until C++20)(C++17)
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.

The following expressions (including conversions to the destination type) are manifestly constant-evaluated:

  • Where a constant expression is grammatically required, including:
  • initializers of static and thread local variables, when all subexpressions of the initializers (including constructor calls and implicit conversions) are constant expressions (that is, when the initializers are constant initializers)

To test the last two conditions, compilers may first perform a trial constant evaluation of the initializers. It is not recommended to depend on the result in this case.

int y;
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_evaluation() == true succeeds.
// Variable b is statically initialized with 2


[edit] Parameters


[edit] 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

[edit] Notes

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

[edit] Example

#include <type_traits>
#include <cmath>
#include <iostream>
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, p = x > 0 ? b : 1.0 / b;
        auto u = unsigned(x > 0 ? x : -x);
        while (u != 0) {
            if (u & 1) r *= p;
            u /= 2;
            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

[edit] See also

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