std::is_constant_evaluated(3)

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.
   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
          * if the initializers are constant expressions, the variables are usable in
            constant expressions
     * static and thread local variables
          * if when all subexpressions of the initializers (including constructor calls
            and implicit conversions) are constant expressions, static initialization
            is performed, which can be asserted by constinit
   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
                        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