std::is_constant_evaluated

From cppreference.com
< cpp‎ | types
 
C++
 
Utilities library
General utilities
Date and time
Function objects
Formatting library (C++20)
(C++11)
Relational operators (deprecated in C++20)
Integer comparison functions
(C++20)(C++20)(C++20)   
(C++20)
Swap and type operations
(C++20)
(C++14)
(C++11)
(C++23)
(C++11)
(C++23)
(C++11)
(C++11)
(C++17)
Common vocabulary types
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++11)
(C++17)
(C++17)
(C++23)
Elementary string conversions
(C++17)
(C++17)
(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.

While testing whether initializers of following variables are constant initializers, compilers may first perform a trial constant evaluation of the initializers:

  • 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;
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

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 by a compiler extension.

Feature-test macro: __cpp_lib_is_constant_evaluated

Example

Run this code
#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)
}

Output: 

1000 1000

See also

constexpr specifier(C++11) specifies that the value of a variable or function can be computed at compile time
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
constinit specifier(C++20) asserts that a variable has static initialization, i.e. zero initialization and constant initialization
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/types/is_constant_evaluated&oldid=137630"