FreeBSD Manual Pages
std::is_constant_evaluated(3) C++ Standard Libarystd::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 evalua- tion of an expression or conversion that is manifestly constant-evaluated; oth- erwise returns false. While testing whether initializers of following variables are con- stant initializers, compilers may first perform a trial constant evaluation of the ini- tializers: * 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 dis- carded. // Variable a is dynamically initialized with 1 const int b = std::is_constant_evaluated() ? 2 : y; // Constant evaluation with std::is_constant_evaluation() == true suc- ceeds. // 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 al- gorithm. 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 ini- tialization, i.e. zero initialization and constant initial- ization http://cppreference.com 2022.07.31 std::is_constant_evaluated(3)
NAME | Synopsis | Parameters | Return value | Possible implementation | Notes | Example | Output: | See also
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::is_constant_evaluated&sektion=3&manpath=FreeBSD+Ports+15.0>