consteval
- specifies that a function is animmediate function, that is, every call to the function must produce a compile-time constant
[edit]Explanation
Theconsteval
specifier declares a function or function template to be animmediate function, that is, everypotentially-evaluated call to the function must (directly or indirectly) produce a compile timeconstant expression.
An immediate function is aconstexpr function, subject to its requirements as the case may be. Same asconstexpr
, aconsteval
specifier impliesinline
. However, it may not be applied to destructors, allocation functions, or deallocation functions.
A function or function template declaration specifyingconsteval
may not also specifyconstexpr
, and any redeclarations of that function or function template must also specifyconsteval
.
Apotentially-evaluated invocation of an immediate function whose innermost non-block scope is not afunction parameter scope of an immediate function or the true-branch of aconsteval if statement(since C++23) must produce a constant expression; such an invocation is known as animmediate invocation.
constevalint sqr(int n){return n*n;}constexprint r= sqr(100);// OK int x=100;int r2= sqr(x);// Error: Call does not produce a constant constevalint sqrsqr(int n){return sqr(sqr(n));// Not a constant expression at this point, but OK} constexprint dblsqr(int n){return2* sqr(n);// Error: Enclosing function is not consteval// and sqr(n) is not a constant}
Anidentifier expression that denotes an immediate function may only appear within a subexpression of an immediate invocation or within animmediate function context (i.e. a context mentioned above, in which a call to an immediate function needs not to be a constant expression). A pointer or reference to an immediate function can be taken but cannot escape constant expression evaluation:
constevalint f(){return42;}constevalauto g(){return&f;}constevalint h(int(*p)()= g()){return p();}constexprint r= h();// OKconstexprauto e= g();// ill-formed: a pointer to an immediate function is// not a permitted result of a constant expression
[edit]Keywords
consteval
[edit]Example
#include <iostream> // This function might be evaluated at compile-time, if the input// is known at compile-time. Otherwise, it is executed at run-time.constexprunsigned factorial(unsigned n){return n<2?1: n* factorial(n-1);} // With consteval we enforce that the function will be evaluated at compile-time.constevalunsigned combination(unsigned m,unsigned n){return factorial(n)/ factorial(m)/ factorial(n- m);} static_assert(factorial(6)==720);static_assert(combination(4,8)==70); int main(int argc,constchar*[]){constexprunsigned x{factorial(4)};std::cout<< x<<'\n'; [[maybe_unused]]unsigned y= factorial(argc);// OK// unsigned z = combination(argc, 7); // error: 'argc' is not a constant expression}
Output:
[edit]See also