home | help 
std::is_constant_evaluated(3)  C++ Standard Libary 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; other-
     wise returns
	false.

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

	  * variables with reference type or const-qualified integral or enumer-
     ation 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 con-
     stexpr 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_evalu-
     ated

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 algo-
     rithm.
	      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	initial-
     ization, i.e.
				   zero  initialization and constant initializa-
     tion

http://cppreference.com 	   2024.06.10	   std::is_constant_evaluated(3)
home | help