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.
   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