• 1Explanation
• 2constexpr variable
• 3constexpr function
• 4constexpr constructor
• 5constexpr destructor
• 6Notes
• 7Keywords
• 8Example
• 9Defect reports
• 10See also

• Thefull-expression of its initialization is aconstant expression.

• It isconstant-initializable.

• It has constant destruction, which means one of the following conditions needs to be satisfied:

• It is not of class type nor (possibly multi-dimensional) array thereof.
• It is of a class type with aconstexpr destructor or (possibly multi-dimensional) array thereof, and for a hypothetical expressione whose only effect is to destroy the object,e would be acore constant expression if the lifetime of the object and its non-mutable subobjects (but not its mutable subobjects) were considered to start withine.

If aconstexpr variable is nottranslation-unit-local, it should not be initialized to refer to a translation-unit-local entity that is usable in constant expressions, nor have a subobject that refers to such an entity. Such initialization is disallowed in amodule interface unit (outside itsprivate module fragment, if any) or a module partition, and is deprecated in any other context.

• It is not avirtual function.

• Its return type (if exists) is aliteral type.
• Each of its parameter types is a literal type.

• It is not acoroutine.

• Its function body is=default,= delete, or a compound statementenclosing only the following:

• null statements
• static_assert declarations
• typedef declarations andalias declarations that do not define classes or enumerations
• using declarations
• using directives
• exactly onereturn statement if the function is not a constructor

• Its function body is=default,= delete, or a compound statement that(until C++20) doesnotenclose the following:

• goto statements
• statements withlabels other thancase anddefault

• definitions of variables of non-literal types
• definitions of variables of static or threadstorage duration

For a non-constructorconstexpr function that is neither defaulted nor templated, if no argument values exist such that an invocation of the function could be an evaluated subexpression of acore constant expression, the program is ill-formed, no diagnostic required.

For a templatedconstexpr function, if no specialization of the function/class template would make the templated function constexpr-suitable when considered as a non-templated function, the program is ill-formed, no diagnostic required.

• Its function body is= delete or satisfies the following additional requirements:

• If the constructor is adelegating constructor, the target constructor is aconstexpr constructor.
• If the constructor is a non-delegating constructor, every constructor selected to initialize non-static data members and base class subobjects is aconstexpr constructor.

For aconstexpr constructor that is neither defaulted nor templated, if no argument values exist such that an invocation of the function could be an evaluated subexpression of the initialization full-expression of some object subject toconstant expression, the program is ill-formed, no diagnostic required.

Destructors cannot beconstexpr, but atrivial destructor can be implicitly called in constant expressions.

On top of the requirements ofconstexpr functions, a destructor also needs to satisfy all following conditions to be constexpr-suitable:

• The class does not have any virtual base class.

Because thenoexcept operator always returnstrue for a constant expression, it can be used to check if a particular invocation of a constexpr function takes the constant expression branch:

constexprint f();constexprbool b1=noexcept(f());// false, undefined constexpr functionconstexprint f(){return0;}constexprbool b2=noexcept(f());// true, f() is a constant expression

It is possible to write a constexpr function whose invocation can never satisfy the requirements of a core constant expression:

void f(int& i)// not a constexpr function{    i=0;} constexprvoid g(int& i)// well-formed since C++23{    f(i);// unconditionally calls f, cannot be a constant expression}

Even thoughtry blocks and inline assembly are allowed in constexpr functions, throwing exceptionsthat are uncaught(since C++26) or executing the assembly is still disallowed in a constant expression.

If a variable has constant destruction, there is no need to generate machine code in order to call destructor for it, even if its destructor is not trivial.

A non-lambda, non-special-member, and non-templated constexpr function cannot implicitly become an immediate function. Users need to explicitly mark itconsteval to make such an intended function definition well-formed.