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. To determine whether initializers of following variables are mani- festly 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 dis- carded. // Variable a is dynamically initialized with 1 const int b = std::is_constant_evaluated() ? 2 : y; // Constant evaluation with std::is_constant_evaluated() == 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 using a compiler extension. Feature-test macro Value Std Feature __cpp_lib_is_constant_evaluated 201811L (C++20) std::is_con- stant_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 al- gorithm. 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 ini- tialization, i.e. zero initialization and constant initial- ization http://cppreference.com 2024.06.10 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.1.quarterly>