7 Expressions [expr]

Postfix expressions group left-to-right.

A subscript expression is a postfix expression followed by square brackets containing a possibly empty, comma-separated list of initializer-clauses that constitute the arguments to the subscript operator.

The postfix-expression and the initialization of the object parameter of any applicable subscript operator function is sequenced before each expression in the expression-list and also before any default argument.

The initialization of a non-object parameter of a subscript operator function S ([over.sub]), including every associated value computation and side effect, is indeterminately sequenced with respect to that of any other non-object parameter of S.

With the built-in subscript operator, an expression-list shall be present, consisting of a single assignment-expression.

One of the expressions shall be a glvalue of type “array of T” or a prvalue of type “pointer to T” and the other shall be a prvalue of unscoped enumeration or integral type.

The result is of type “T”.

The type “T” shall be a completely-defined object type.49

The expression E1[E2] is identical (by definition) to *((E1)+(E2)), except that in the case of an array operand, the result is an lvalue if that operand is an lvalue and an xvalue otherwise.

A function call is a postfix expression followed by parentheses containing a possibly empty, comma-separated list of initializer-clauses which constitute the arguments to the function.

The postfix expression shall have function type or function pointer type.

For a call to a non-member function or to a static member function, the postfix expression shall be either an lvalue that refers to a function (in which case the function-to-pointer standard conversion ([conv.func]) is suppressed on the postfix expression), or a prvalue of function pointer type.

If the selected function is non-virtual, or if the id-expression in the class member access expression is a qualified-id, that function is called.

Otherwise, its final overrider in the dynamic type of the object expression is called; such a call is referred to as a virtual function call.

If the postfix-expression names a destructor or pseudo-destructor ([expr.prim.id.dtor]), the type of the function call expression is void; otherwise, the type of the function call expression is the return type of the statically chosen function (i.e., ignoring the virtual keyword), even if the type of the function actually called is different.

If the postfix-expression names a pseudo-destructor (in which case the postfix-expression is a possibly-parenthesized class member access), the function call destroys the object of scalar type denoted by the object expression of the class member access ([expr.ref], [basic.life]).

A type ${\text{T}}_{\text{call}}$ is call-compatible with a function type ${\text{T}}_{\text{func}}$ if ${\text{T}}_{\text{call}}$ is the same type as ${\text{T}}_{\text{func}}$ or if the type “pointer to ${\text{T}}_{\text{func}}$” can be converted to type “pointer to ${\text{T}}_{\text{call}}$” via a function pointer conversion ([conv.fctptr]).

Calling a function through an expression whose function type is not call-compatible with the type of the called function's definition results in undefined behavior.

When a function is called, each parameter ([dcl.fct]) is initialized ([dcl.init], [class.copy.ctor]) with its corresponding argument.

If the function is an explicit object member function and there is an implied object argument ([over.call.func]), the list of provided arguments is preceded by the implied object argument for the purposes of this correspondence.

If there is no corresponding argument, the default argument for the parameter is used.

If the function is an implicit object member function, the object expression of the class member access shall be a glvalue and the implicit object parameter of the function ([over.match.funcs]) is initialized with that glvalue, converted as if by an explicit type conversion.

When a function is called, the type of any parameter shall not be a class type that is either incomplete or abstract.

It is implementation-defined whether a parameter is destroyed when the function in which it is defined exits ([stmt.return], [except.ctor]) or at the end of the enclosing full-expression; parameters are always destroyed in the reverse order of their construction.

The initialization and destruction of each parameter occurs within the context of the full-expression ([intro.execution]) where the function call appears.

The postfix-expression is sequenced before each expression in the expression-list and any default argument.

The initialization of a parameter, including every associated value computation and side effect, is indeterminately sequenced with respect to that of any other parameter.

The result of a function call is the result of the possibly-converted operand of the return statement ([stmt.return]) that transferred control out of the called function (if any), except in a virtual function call if the return type of the final overrider is different from the return type of the statically chosen function, the value returned from the final overrider is converted to the return type of the statically chosen function.

A function can be declared to accept fewer arguments (by declaring default arguments) or more arguments (by using the ellipsis, ..., or a function parameter pack ([dcl.fct])) than the number of parameters in the function definition.

When there is no parameter for a given argument, the argument is passed in such a way that the receiving function can obtain the value of the argument by invoking va_arg.

The lvalue-to-rvalue, array-to-pointer, and function-to-pointer standard conversions are performed on the argument expression.

An argument that has type cv std​::​nullptr_t is converted to type void* ([conv.ptr]).

After these conversions, if the argument does not have arithmetic, enumeration, pointer, pointer-to-member, or class type, the program is ill-formed.

Passing a potentially-evaluated argument of a scoped enumeration type ([dcl.enum]) or of a class type ([class]) having an eligible non-trivial copy constructor ([special], [class.copy.ctor]), an eligible non-trivial move constructor, or a non-trivial destructor ([class.dtor]), with no corresponding parameter, is conditionally-supported with implementation-defined semantics.

If the argument has integral or enumeration type that is subject to the integral promotions, or a floating-point type that is subject to the floating-point promotion, the value of the argument is converted to the promoted type before the call.

These promotions are referred to as the default argument promotions.

Recursive calls are permitted, except to the main function.

A function call is an lvalue if the result type is an lvalue reference type or an rvalue reference to function type, an xvalue if the result type is an rvalue reference to object type, and a prvalue otherwise.

A simple-type-specifier or typename-specifier followed by a parenthesized optional expression-list or by a braced-init-list (the initializer) constructs a value of the specified type given the initializer.

If the type is a placeholder for a deduced class type, it is replaced by the return type of the function selected by overload resolution for class template deduction for the remainder of this subclause.

Otherwise, if the type contains a placeholder type, it is replaced by the type determined by placeholder type deduction ([dcl.type.auto.deduct]).

If the initializer is a parenthesized single expression, the type conversion expression is equivalent to the corresponding cast expression.

Otherwise, if the type is cv void and the initializer is () or {} (after pack expansion, if any), the expression is a prvalue of type void that performs no initialization.

Otherwise, the expression is a prvalue of the specified type whose result object is direct-initialized with the initializer.

If the initializer is a parenthesized optional expression-list, the specified type shall not be an array type.

A postfix expression followed by a dot . or an arrow ->, optionally followed by the keyword template, and then followed by an id-expression, is a postfix expression.

For the first option (dot), if the id-expression names a static member or an enumerator, the first expression is a discarded-value expression ([expr.context]); if the id-expression names a non-static data member, the first expression shall be a glvalue.

For the second option (arrow), the first expression shall be a prvalue having pointer type.

The expression E1->E2 is converted to the equivalent form (*(E1)).E2; the remainder of [expr.ref] will address only the first option (dot).50

The postfix expression before the dot is evaluated;51 the result of that evaluation, together with the id-expression, determines the result of the entire postfix expression.

Abbreviating postfix-expression.id-expression as E1.E2, E1 is called the object expression.

If the object expression is of scalar type, E2 shall name the pseudo-destructor of that same type (ignoring cv-qualifications) and E1.E2 is a prvalue of type “function of () returning void”.

Otherwise, the object expression shall be of class type.

The class type shall be complete unless the class member access appears in the definition of that class.

If E2 is a bit-field, E1.E2 is a bit-field.

The type and value category of E1.E2 are determined as follows.

In the remainder of [expr.ref], cq represents either const or the absence of const and vq represents either volatile or the absence of volatile.

cv represents an arbitrary set of cv-qualifiers, as defined in [basic.type.qualifier].

If E2 is declared to have type “reference to T”, then E1.E2 is an lvalue of type T.

If E2 is a static data member, E1.E2 designates the object or function to which the reference is bound, otherwise E1.E2 designates the object or function to which the corresponding reference member of E1 is bound.

Otherwise, one of the following rules applies.

If E2 is a non-static member, the program is ill-formed if the class of which E2 is directly a member is an ambiguous base ([class.member.lookup]) of the naming class ([class.access.base]) of E2.

If E2 is a non-static member and the result of E1 is an object whose type is not similar ([conv.qual]) to the type of E1, the behavior is undefined.

The value of a postfix ++ expression is the value of its operand.

The operand shall be a modifiable lvalue.

The type of the operand shall be an arithmetic type other than cv bool, or a pointer to a complete object type.

An operand with volatile-qualified type is deprecated; see [depr.volatile.type].

The value of the operand object is modified ([defns.access]) as if it were the operand of the prefix ++ operator ([expr.pre.incr]).

The value computation of the ++ expression is sequenced before the modification of the operand object.

With respect to an indeterminately-sequenced function call, the operation of postfix ++ is a single evaluation.

The result is a prvalue.

The type of the result is the cv-unqualified version of the type of the operand.

The operand of postfix -- is decremented analogously to the postfix ++ operator.

The result of the expression dynamic_cast<T>(v) is the result of converting the expression v to type T.

T shall be a pointer or reference to a complete class type, or “pointer to cv void”.

The dynamic_cast operator shall not cast away constness ([expr.const.cast]).

If T is a pointer type, v shall be a prvalue of a pointer to complete class type, and the result is a prvalue of type T.

If T is an lvalue reference type, v shall be an lvalue of a complete class type, and the result is an lvalue of the type referred to by T.

If T is an rvalue reference type, v shall be a glvalue having a complete class type, and the result is an xvalue of the type referred to by T.

If the type of v is the same as T (ignoring cv-qualifications), the result is v (converted if necessary).

If T is “pointer to cv1 B” and v has type “pointer to cv2 D” such that B is a base class of D, the result is a pointer to the unique B subobject of the D object pointed to by v, or a null pointer value if v is a null pointer value.

Similarly, if T is “reference to cv1 B” and v has type cv2 D such that B is a base class of D, the result is the unique B subobject of the D object referred to by v.52

In both the pointer and reference cases, the program is ill-formed if B is an inaccessible or ambiguous base class of D.

Otherwise, v shall be a pointer to or a glvalue of a polymorphic type.

If v is a null pointer value, the result is a null pointer value.

If v has type “pointer to cv U” and v does not point to an object whose type is similar ([conv.qual]) to U and that is within its lifetime or within its period of construction or destruction ([class.cdtor]), the behavior is undefined.

If v is a glvalue of type U and v does not refer to an object whose type is similar to U and that is within its lifetime or within its period of construction or destruction, the behavior is undefined.

If T is “pointer to cv void”, then the result is a pointer to the most derived object pointed to by v.

Otherwise, a runtime check is applied to see if the object pointed or referred to by v can be converted to the type pointed or referred to by T.

Let C be the class type to which T points or refers.

The runtime check logically executes as follows:

• (9.1)
  If, in the most derived object pointed (referred) to by v, v points (refers) to a public base class subobject of a C object, and if only one object of type C is derived from the subobject pointed (referred) to by v, the result points (refers) to that C object.
• (9.2)
  Otherwise, if v points (refers) to a public base class subobject of the most derived object, and the type of the most derived object has a base class, of type C, that is unambiguous and public, the result points (refers) to the C subobject of the most derived object.
• (9.3)
  Otherwise, the runtime check fails.

The value of a failed cast to pointer type is the null pointer value of the required result type.

A failed cast to reference type throws an exception of a type that would match a handler of type std​::​bad_cast.

The result of a typeid expression is an lvalue of static type const std​::​type_info ([type.info]) and dynamic type const std​::​type_info or const name where name is an implementation-defined class publicly derived from std​::​type_info which preserves the behavior described in [type.info].53

The lifetime of the object referred to by the lvalue extends to the end of the program.

Whether or not the destructor is called for the std​::​type_info object at the end of the program is unspecified.

If the type of the expression or type-id operand is a (possibly cv-qualified) class type or a reference to (possibly cv-qualified) class type, that class shall be completely defined.

If an expression operand of typeid is a possibly-parenthesized unary-expression whose unary-operator is * and whose operand evaluates to a null pointer value ([basic.compound]), the typeid expression throws an exception ([except.throw]) of a type that would match a handler of type std​::​bad_typeid ([bad.typeid]).

When typeid is applied to a glvalue whose type is a polymorphic class type ([class.virtual]), the result refers to a std​::​type_info object representing the type of the most derived object ([intro.object]) (that is, the dynamic type) to which the glvalue refers.

When typeid is applied to an expression other than a glvalue of a polymorphic class type, the result refers to a std​::​type_info object representing the static type of the expression.

Lvalue-to-rvalue, array-to-pointer, and function-to-pointer conversions are not applied to the expression.

If the expression is a prvalue, the temporary materialization conversion is applied.

The expression is an unevaluated operand.

When typeid is applied to a type-id, the result refers to a std​::​type_info object representing the type of the type-id.

If the type of the type-id is a reference to a possibly cv-qualified type, the result of the typeid expression refers to a std​::​type_info object representing the cv-unqualified referenced type.

If the type of the expression or type-id is a cv-qualified type, the result of the typeid expression refers to a std​::​type_info object representing the cv-unqualified type.

The type std​::​type_info ([type.info]) is not predefined; if a standard library declaration ([typeinfo.syn], [std.modules]) of std​::​type_info does not precede ([basic.lookup.general]) a typeid expression, the program is ill-formed.

The result of the expression static_cast<T>(v) is the result of converting the expression v to type T.

If T is an lvalue reference type or an rvalue reference to function type, the result is an lvalue; if T is an rvalue reference to object type, the result is an xvalue; otherwise, the result is a prvalue.

The static_cast operator shall not cast away constness ([expr.const.cast]).

An lvalue of type “cv1 B”, where B is a class type, can be cast to type “reference to cv2 D”, where D is a complete class derived ([class.derived]) from B, if cv2 is the same cv-qualification as, or greater cv-qualification than, cv1.

If B is a virtual base class of D or a base class of a virtual base class of D, or if no valid standard conversion from “pointer to D” to “pointer to B” exists ([conv.ptr]), the program is ill-formed.

An xvalue of type “cv1 B” can be cast to type “rvalue reference to cv2 D” with the same constraints as for an lvalue of type “cv1 B”.

If the object of type “cv1 B” is actually a base class subobject of an object of type D, the result refers to the enclosing object of type D.

Otherwise, the behavior is undefined.

An lvalue of type T1 can be cast to type “rvalue reference to T2” if T2 is reference-compatible with T1 ([dcl.init.ref]).

If the value is not a bit-field, the result refers to the object or the specified base class subobject thereof; otherwise, the lvalue-to-rvalue conversion is applied to the bit-field and the resulting prvalue is used as the operand of the static_cast for the remainder of this subclause.

If T2 is an inaccessible ([class.access]) or ambiguous ([class.member.lookup]) base class of T1, a program that necessitates such a cast is ill-formed.

Any expression can be explicitly converted to type cv void, in which case the operand is a discarded-value expression ([expr.prop]).

Otherwise, an expression E can be explicitly converted to a type T if there is an implicit conversion sequence ([over.best.ics]) from E to T, if overload resolution for a direct-initialization ([dcl.init]) of an object or reference of type T from E would find at least one viable function ([over.match.viable]), or if T is an aggregate type ([dcl.init.aggr]) having a first element x and there is an implicit conversion sequence from E to the type of x.

If T is a reference type, the effect is the same as performing the declaration and initialization T t(E); for some invented temporary variable t ([dcl.init]) and then using the temporary variable as the result of the conversion.

Otherwise, the result object is direct-initialized from E.

Otherwise, the inverse of a standard conversion sequence ([conv]) not containing an lvalue-to-rvalue ([conv.lval]), array-to-pointer ([conv.array]), function-to-pointer ([conv.func]), null pointer ([conv.ptr]), null member pointer ([conv.mem]), boolean ([conv.bool]), or function pointer ([conv.fctptr]) conversion, can be performed explicitly using static_cast.

A program is ill-formed if it uses static_cast to perform the inverse of an ill-formed standard conversion sequence.

The lvalue-to-rvalue ([conv.lval]), array-to-pointer ([conv.array]), and function-to-pointer ([conv.func]) conversions are applied to the operand.

Such a static_cast is subject to the restriction that the explicit conversion does not cast away constness ([expr.const.cast]), and the following additional rules for specific cases:

A value of a scoped enumeration type ([dcl.enum]) can be explicitly converted to an integral type; the result is the same as that of converting to the enumeration's underlying type and then to the destination type.

A value of a scoped enumeration type can also be explicitly converted to a floating-point type; the result is the same as that of converting from the original value to the floating-point type.

A value of integral or enumeration type can be explicitly converted to a complete enumeration type.

If the enumeration type has a fixed underlying type, the value is first converted to that type by integral promotion ([conv.prom]) or integral conversion ([conv.integral]), if necessary, and then to the enumeration type.

If the enumeration type does not have a fixed underlying type, the value is unchanged if the original value is within the range of the enumeration values ([dcl.enum]), and otherwise, the behavior is undefined.

A value of floating-point type can also be explicitly converted to an enumeration type.

The resulting value is the same as converting the original value to the underlying type of the enumeration ([conv.fpint]), and subsequently to the enumeration type.

A prvalue of floating-point type can be explicitly converted to any other floating-point type.

If the source value can be exactly represented in the destination type, the result of the conversion has that exact representation.

If the source value is between two adjacent destination values, the result of the conversion is an implementation-defined choice of either of those values.

Otherwise, the behavior is undefined.

A prvalue of type “pointer to cv1 B”, where B is a class type, can be converted to a prvalue of type “pointer to cv2 D”, where D is a complete class derived from B, if cv2 is the same cv-qualification as, or greater cv-qualification than, cv1.

If B is a virtual base class of D or a base class of a virtual base class of D, or if no valid standard conversion from “pointer to D” to “pointer to B” exists ([conv.ptr]), the program is ill-formed.

The null pointer value ([basic.compound]) is converted to the null pointer value of the destination type.

If the prvalue of type “pointer to cv1 B” points to a B that is actually a base class subobject of an object of type D, the resulting pointer points to the enclosing object of type D.

Otherwise, the behavior is undefined.

A prvalue of type “pointer to member of D of type cv1 T” can be converted to a prvalue of type “pointer to member of B of type cv2 T”, where D is a complete class type and B is a base class of D, if cv2 is the same cv-qualification as, or greater cv-qualification than, cv1.

If no valid standard conversion from “pointer to member of B of type T” to “pointer to member of D of type T” exists ([conv.mem]), the program is ill-formed.

The null member pointer value is converted to the null member pointer value of the destination type.

If class B contains the original member, or is a base class of the class containing the original member, the resulting pointer to member points to the original member.

Otherwise, the behavior is undefined.

A prvalue of type “pointer to cv1 void” can be converted to a prvalue of type “pointer to cv2 T”, where T is an object type and cv2 is the same cv-qualification as, or greater cv-qualification than, cv1.

If the original pointer value represents the address A of a byte in memory and A does not satisfy the alignment requirement of T, then the resulting pointer value ([basic.compound]) is unspecified.

Otherwise, if the original pointer value points to an object a, and there is an object b of type similar to T that is pointer-interconvertible with a, the result is a pointer to b.

Otherwise, the pointer value is unchanged by the conversion.

No other conversion can be performed using static_cast.

The result of the expression reinterpret_cast<T>(v) is the result of converting the expression v to type T.

If T is an lvalue reference type or an rvalue reference to function type, the result is an lvalue; if T is an rvalue reference to object type, the result is an xvalue; otherwise, the result is a prvalue and the lvalue-to-rvalue, array-to-pointer, and function-to-pointer standard conversions are performed on the expression v.

Conversions that can be performed explicitly using reinterpret_cast are listed below.

No other conversion can be performed explicitly using reinterpret_cast.

The reinterpret_cast operator shall not cast away constness ([expr.const.cast]).

An expression of integral, enumeration, pointer, or pointer-to-member type can be explicitly converted to its own type; such a cast yields the value of its operand.

A pointer can be explicitly converted to any integral type large enough to hold all values of its type.

The mapping function is implementation-defined.

A value of type std​::​nullptr_t can be converted to an integral type; the conversion has the same meaning and validity as a conversion of (void*)0 to the integral type.

A value of integral type or enumeration type can be explicitly converted to a pointer.

A pointer converted to an integer of sufficient size (if any such exists on the implementation) and back to the same pointer type will have its original value ([basic.compound]); mappings between pointers and integers are otherwise implementation-defined.

A function pointer can be explicitly converted to a function pointer of a different type.

Except that converting a prvalue of type “pointer to T1” to the type “pointer to T2” (where T1 and T2 are function types) and back to its original type yields the original pointer value, the result of such a pointer conversion is unspecified.

An object pointer can be explicitly converted to an object pointer of a different type.54

When a prvalue v of object pointer type is converted to the object pointer type “pointer to cv T”, the result is static_cast<cv T*>(static_cast<cv void*>(v)).

Converting a function pointer to an object pointer type or vice versa is conditionally-supported.

The meaning of such a conversion is implementation-defined, except that if an implementation supports conversions in both directions, converting a prvalue of one type to the other type and back, possibly with different cv-qualification, shall yield the original pointer value.

The null pointer value ([basic.compound]) is converted to the null pointer value of the destination type.

A prvalue of type “pointer to member of X of type T1” can be explicitly converted to a prvalue of a different type “pointer to member of Y of type T2” if T1 and T2 are both function types or both object types.55

The null member pointer value ([conv.mem]) is converted to the null member pointer value of the destination type.

The result of this conversion is unspecified, except in the following cases:

• (10.1)
  Converting a prvalue of type “pointer to member function” to a different pointer-to-member-function type and back to its original type yields the original pointer-to-member value.
• (10.2)
  Converting a prvalue of type “pointer to data member of X of type T1” to the type “pointer to data member of Y of type T2” (where the alignment requirements of T2 are no stricter than those of T1) and back to its original type yields the original pointer-to-member value.

A glvalue of type T1, designating an object or function x, can be cast to the type “reference to T2” if an expression of type “pointer to T1” can be explicitly converted to the type “pointer to T2” using a reinterpret_cast.

The result is that of *reinterpret_cast<T2 *>(p) where p is a pointer to x of type “pointer to T1”.

No temporary is created, no copy is made, and no constructors ([class.ctor]) or conversion functions ([class.conv]) are called.56

The result of the expression const_cast<T>(v) is of type T.

If T is an lvalue reference to object type, the result is an lvalue; if T is an rvalue reference to object type, the result is an xvalue; otherwise, the result is a prvalue and the lvalue-to-rvalue, array-to-pointer, and function-to-pointer standard conversions are performed on the expression v.

Conversions that can be performed explicitly using const_cast are listed below.

No other conversion shall be performed explicitly using const_cast.

For two similar types T1 and T2, a prvalue of type T1 may be explicitly converted to the type T2 using a const_cast if, considering the qualification-decompositions of both types, each $P_i^1$ is the same as $P_i^2$ for all i.

The result of a const_cast refers to the original entity.

For two object types T1 and T2, if a pointer to T1 can be explicitly converted to the type “pointer to T2” using a const_cast, then the following conversions can also be made:

• (4.1)
  an lvalue of type T1 can be explicitly converted to an lvalue of type T2 using the cast const_cast<T2&>;
• (4.2)
  a glvalue of type T1 can be explicitly converted to an xvalue of type T2 using the cast const_cast<T2&&>; and
• (4.3)
  if T1 is a class type, a prvalue of type T1 can be explicitly converted to an xvalue of type T2 using the cast const_cast<T2&&>.

The result of a reference const_cast refers to the original object if the operand is a glvalue and to the result of applying the temporary materialization conversion otherwise.

A null pointer value ([basic.compound]) is converted to the null pointer value of the destination type.

The null member pointer value ([conv.mem]) is converted to the null member pointer value of the destination type.

A conversion from a type T1 to a type T2 casts away constness if T1 and T2 are different, there is a qualification-decomposition ([conv.qual]) of T1 yielding n such that T2 has a qualification-decomposition of the form $cv{}_0^2$ $P_0^2$ $cv{}_1^2$ $P_1^2$ ⋯ $cv{}_{n-1}^2$ $P_{n-1}^2$ $cv{}_n^2$ $U_2$, and there is no qualification conversion that converts T1 to $cv{}_0^2$ $P_0^1$ $cv{}_1^2$ $P_1^1$ ⋯ $cv{}_{n-1}^2$ $P_{n-1}^1$ $cv{}_n^2$ $U_1$.

Casting from an lvalue of type T1 to an lvalue of type T2 using an lvalue reference cast or casting from an expression of type T1 to an xvalue of type T2 using an rvalue reference cast casts away constness if a cast from a prvalue of type “pointer to T1” to the type “pointer to T2” casts away constness.

Expressions with unary operators group right-to-left.

The unary * operator performs indirection.

Its operand shall be a prvalue of type “pointer to T”, where T is an object or function type.

The operator yields an lvalue of type T.

If the operand points to an object or function, the result denotes that object or function; otherwise, the behavior is undefined except as specified in [expr.typeid].

Each of the following unary operators yields a prvalue.

The operand of the unary & operator shall be an lvalue of some type T.

A pointer to member is only formed when an explicit & is used and its operand is a qualified-id not enclosed in parentheses.

If & is applied to an lvalue of incomplete class type and the complete type declares operator&(), it is unspecified whether the operator has the built-in meaning or the operator function is called.

The operand of & shall not be a bit-field.

The operand of the unary + operator shall be a prvalue of arithmetic, unscoped enumeration, or pointer type and the result is the value of the argument.

Integral promotion is performed on integral or enumeration operands.

The type of the result is the type of the promoted operand.

The operand of the unary - operator shall be a prvalue of arithmetic or unscoped enumeration type and the result is the negative of its operand.

Integral promotion is performed on integral or enumeration operands.

The negative of an unsigned quantity is computed by subtracting its value from $2^n$, where n is the number of bits in the promoted operand.

The type of the result is the type of the promoted operand.

The operand of the logical negation operator ! is contextually converted to bool ([conv]); its value is true if the converted operand is false and false otherwise.

The type of the result is bool.

The operand of the ~ operator shall be a prvalue of integral or unscoped enumeration type.

Integral promotions are performed.

The type of the result is the type of the promoted operand.

Given the coefficients ${\text{x}}_i$ of the base-2 representation ([basic.fundamental]) of the promoted operand x, the coefficient ${\text{r}}_i$ of the base-2 representation of the result r is 1 if ${\text{x}}_i$ is 0, and 0 otherwise.

There is an ambiguity in the grammar when ~ is followed by a type-name or computed-type-specifier.

The ambiguity is resolved by treating ~ as the operator rather than as the start of an unqualified-id naming a destructor.

The operand of prefix ++ or -- shall not be of type cv bool.

An operand with volatile-qualified type is deprecated; see [depr.volatile.type].

The expression ++x is otherwise equivalent to x+=1 and the expression --x is otherwise equivalent to x-=1 ([expr.ass]).

The co_await expression is used to suspend evaluation of a coroutine ([dcl.fct.def.coroutine]) while awaiting completion of the computation represented by the operand expression.

Suspending the evaluation of a coroutine transfers control to its caller or resumer.

An await-expression shall appear only as a potentially-evaluated expression within the compound-statement of a function-body or lambda-expression, in either case outside of a handler ([except.pre]).

In a declaration-statement or in the simple-declaration (if any) of an init-statement, an await-expression shall appear only in an initializer of that declaration-statement or simple-declaration.

An await-expression shall not appear in a default argument ([dcl.fct.default]).

An await-expression shall not appear in the initializer of a block variable with static or thread storage duration.

A context within a function where an await-expression can appear is called a suspension context of the function.

Evaluation of an await-expression involves the following auxiliary types, expressions, and objects:

• (3.1)
  p is an lvalue naming the promise object ([dcl.fct.def.coroutine]) of the enclosing coroutine and P is the type of that object.
• (3.2)
  Unless the await-expression was implicitly produced by a yield-expression ([expr.yield]), an initial await expression, or a final await expression ([dcl.fct.def.coroutine]), a search is performed for the name await_transform in the scope of P ([class.member.lookup]).

  If this search is performed and finds at least one declaration, then a is p.await_transform(cast-expression); otherwise, a is the cast-expression.
• (3.3)
  o is determined by enumerating the applicable operator co_await functions for an argument a ([over.match.oper]), and choosing the best one through overload resolution ([over.match]).

  If overload resolution is ambiguous, the program is ill-formed.

  If no viable functions are found, o is a.

  Otherwise, o is a call to the selected function with the argument a.

  If o would be a prvalue, the temporary materialization conversion ([conv.rval]) is applied.
• (3.4)
  e is an lvalue referring to the result of evaluating the (possibly-converted) o.
• (3.5)
  h is an object of type std​::​coroutine_handle<P> referring to the enclosing coroutine.
• (3.6)
  await-ready is the expression e.await_ready(), contextually converted to bool.
• (3.7)
  await-suspend is the expression e.await_suspend(h), which shall be a prvalue of type void, bool, or std​::​coroutine_handle<Z> for some type Z.
• (3.8)
  await-resume is the expression e.await_resume().

The await-expression has the same type and value category as the await-resume expression.

The await-expression evaluates the (possibly-converted) o expression and the await-ready expression, then:

• (5.1)
  If the result of await-ready is false, the coroutine is considered suspended.

  Then:

  • (5.1.1)
    If the type of await-suspend is std​::​coroutine_handle<Z>, await-suspend.resume() is evaluated.

    [Note 1: 

    This resumes the coroutine referred to by the result of await-suspend.

    Any number of coroutines can be successively resumed in this fashion, eventually returning control flow to the current coroutine caller or resumer ([dcl.fct.def.coroutine]).

    — end note]
  • (5.1.2)
    Otherwise, if the type of await-suspend is bool, await-suspend is evaluated, and the coroutine is resumed if the result is false.
  • (5.1.3)
    Otherwise, await-suspend is evaluated.

  If the evaluation of await-suspend exits via an exception, the exception is caught, the coroutine is resumed, and the exception is immediately rethrown ([except.throw]).

  Otherwise, control flow returns to the current coroutine caller or resumer ([dcl.fct.def.coroutine]) without exiting any scopes ([stmt.jump]).

  The point in the coroutine immediately prior to control returning to its caller or resumer is a coroutine suspend point.
• (5.2)
  If the result of await-ready is true, or when the coroutine is resumed other than by rethrowing an exception from await-suspend, the await-resume expression is evaluated, and its result is the result of the await-expression.

The sizeof operator yields the number of bytes occupied by a non-potentially-overlapping object of the type of its operand.

The operand is either an expression, which is an unevaluated operand, or a parenthesized type-id.

The sizeof operator shall not be applied to an expression that has function or incomplete type, to the parenthesized name of such types, or to a glvalue that designates a bit-field.

The result of sizeof applied to any of the narrow character types is 1.

The result of sizeof applied to any other fundamental type ([basic.fundamental]) is implementation-defined.

When applied to a reference type, the result is the size of the referenced type.

When applied to a class, the result is the number of bytes in an object of that class including any padding required for placing objects of that type in an array.

The result of applying sizeof to a potentially-overlapping subobject is the size of the type, not the size of the subobject.59

When applied to an array, the result is the total number of bytes in the array.

This implies that the size of an array of n elements is n times the size of an element.

The lvalue-to-rvalue ([conv.lval]), array-to-pointer ([conv.array]), and function-to-pointer ([conv.func]) standard conversions are not applied to the operand of sizeof.

If the operand is a prvalue, the temporary materialization conversion is applied.

The identifier in a sizeof... expression shall name a pack.

The sizeof... operator yields the number of elements in the pack ([temp.variadic]).

A sizeof... expression is a pack expansion ([temp.variadic]).

The result of sizeof and sizeof... is a prvalue of type std​::​size_t.

An alignof expression yields the alignment requirement of its operand type.

The operand shall be a type-id representing a complete object type, or an array thereof, or a reference to one of those types.

The result is a prvalue of type std​::​size_t.

When alignof is applied to a reference type, the result is the alignment of the referenced type.

When alignof is applied to an array type, the result is the alignment of the element type.

The operand of the noexcept operator is an unevaluated operand ([expr.context]).

If the operand is a prvalue, the temporary materialization conversion ([conv.rval]) is applied.

The result of the noexcept operator is a prvalue of type bool.

The result is false if the full-expression of the operand is potentially-throwing ([except.spec]), and true otherwise.

The new-expression attempts to create an object of the type-id or new-type-id ([dcl.name]) to which it is applied.

The type of that object is the allocated type.

This type shall be a complete object type ([basic.types.general]), but not an abstract class type ([class.abstract]) or array thereof ([intro.object]).

If a placeholder type or a placeholder for a deduced class type ([dcl.type.class.deduct]) appears in the type-specifier-seq of a new-type-id or type-id of a new-expression, the allocated type is deduced as follows: Let init be the new-initializer, if any, and T be the new-type-id or type-id of the new-expression, then the allocated type is the type deduced for the variable x in the invented declaration ([dcl.spec.auto]): T x init ;

The new-type-id in a new-expression is the longest possible sequence of new-declarators.

The attribute-specifier-seq in a noptr-new-declarator appertains to the associated array type.

Every constant-expression in a noptr-new-declarator shall be a converted constant expression ([expr.const]) of type std​::​size_t and its value shall be greater than zero.

If the type-id or new-type-id denotes an array type of unknown bound ([dcl.array]), the new-initializer shall not be omitted; the allocated object is an array with n elements, where n is determined from the number of initial elements supplied in the new-initializer ([dcl.init.aggr], [dcl.init.string]).

If the expression in a noptr-new-declarator is present, it is implicitly converted to std​::​size_t.

The value of the expression is invalid if

• (8.1)
  the expression is of non-class type and its value before converting to std​::​size_t is less than zero;
• (8.2)
  the expression is of class type and its value before application of the second standard conversion ([over.ics.user])60 is less than zero;
• (8.3)
  its value is such that the size of the allocated object would exceed the implementation-defined limit; or
• (8.4)
  the new-initializer is a braced-init-list and the number of array elements for which initializers are provided (including the terminating '\0' in a string-literal ([lex.string])) exceeds the number of elements to initialize.

If the value of the expression is invalid after converting to std​::​size_t:

• (8.5)
  if the expression is a potentially-evaluated core constant expression, the program is ill-formed;
• (8.6)
  otherwise, an allocation function is not called; instead
  • (8.6.1)
    if the allocation function that would have been called has a non-throwing exception specification ([except.spec]), the value of the new-expression is the null pointer value of the required result type;
  • (8.6.2)
    otherwise, the new-expression terminates by throwing an exception of a type that would match a handler ([except.handle]) of type std​::​bad_array_new_length.

When the value of the expression is zero, the allocation function is called to allocate an array with no elements.

If the allocated type is an array, the new-initializer is a braced-init-list, and the expression is potentially-evaluated and not a core constant expression, the semantic constraints of copy-initializing a hypothetical element of the array from an empty initializer list are checked ([dcl.init.list]).

Objects created by a new-expression have dynamic storage duration ([basic.stc.dynamic]).

When the allocated type is “array of N T” (that is, the noptr-new-declarator syntax is used or the new-type-id or type-id denotes an array type), the new-expression yields a prvalue of type “pointer to T” that points to the initial element (if any) of the array.

Otherwise, let T be the allocated type; the new-expression is a prvalue of type “pointer to T” that points to the object created.

A new-expression may obtain storage for the object by calling an allocation function ([basic.stc.dynamic.allocation]).

If the new-expression terminates by throwing an exception, it may release storage by calling a deallocation function.

If the allocated type is a non-array type, the allocation function's name is operator new and the deallocation function's name is operator delete.

If the allocated type is an array type, the allocation function's name is operator new[] and the deallocation function's name is operator delete[].

If the new-expression does not begin with a unary ​::​ operator and the allocated type is a class type T or array thereof, a search is performed for the allocation function's name in the scope of T ([class.member.lookup]).

Otherwise, or if nothing is found, the allocation function's name is looked up by searching for it in the global scope.

An implementation is allowed to omit a call to a replaceable global allocation function ([new.delete.single], [new.delete.array]).

When it does so, the storage is instead provided by the implementation or provided by extending the allocation of another new-expression.

During an evaluation of a constant expression, a call to a replaceable allocation function is always omitted ([expr.const]).

The implementation may extend the allocation of a new-expression e1 to provide storage for a new-expression e2 if the following would be true were the allocation not extended:

• (16.1)
  the evaluation of e1 is sequenced before the evaluation of e2, and
• (16.2)
  e2 is evaluated whenever e1 obtains storage, and
• (16.3)
  both e1 and e2 invoke the same replaceable global allocation function, and
• (16.4)
  if the allocation function invoked by e1 and e2 is throwing, any exceptions thrown in the evaluation of either e1 or e2 would be first caught in the same handler, and
• (16.5)
  the pointer values produced by e1 and e2 are operands to evaluated delete-expressions, and
• (16.6)
  the evaluation of e2 is sequenced before the evaluation of the delete-expression whose operand is the pointer value produced by e1.

When a new-expression calls an allocation function and that allocation has not been extended, the new-expression passes the amount of space requested to the allocation function as the first argument of type std​::​size_t.

That argument shall be no less than the size of the object being created; it may be greater than the size of the object being created only if the object is an array and the allocation function is not a non-allocating form ([new.delete.placement]).

For arrays of char, unsigned char, and std​::​byte, the difference between the result of the new-expression and the address returned by the allocation function shall be an integral multiple of the strictest fundamental alignment requirement of any object type whose size is no greater than the size of the array being created.

When a new-expression calls an allocation function and that allocation has been extended, the size argument to the allocation call shall be no greater than the sum of the sizes for the omitted calls as specified above, plus the size for the extended call had it not been extended, plus any padding necessary to align the allocated objects within the allocated memory.

The new-placement syntax is used to supply additional arguments to an allocation function; such an expression is called a placement new-expression.

Overload resolution is performed on a function call created by assembling an argument list.

The first argument is the amount of space requested, and has type std​::​size_t.

If the type of the allocated object has new-extended alignment, the next argument is the type's alignment, and has type std​::​align_val_t.

If the new-placement syntax is used, the initializer-clauses in its expression-list are the succeeding arguments.

If no matching function is found then

• (20.1)
  if the allocated object type has new-extended alignment, the alignment argument is removed from the argument list;
• (20.2)
  otherwise, an argument that is the type's alignment and has type std​::​align_val_t is added into the argument list immediately after the first argument;

and then overload resolution is performed again.

If the allocation function is a non-allocating form ([new.delete.placement]) that returns null, the behavior is undefined.

Otherwise, if the allocation function returns null, initialization shall not be done, the deallocation function shall not be called, and the value of the new-expression shall be null.

A new-expression that creates an object of type T initializes that object as follows:

• (24.1)
  If the new-initializer is omitted, the object is default-initialized ([dcl.init]).

  [Note 12: 

  If no initialization is performed, the object has an indeterminate value.

  — end note]
• (24.2)
  Otherwise, the new-initializer is interpreted according to the initialization rules of [dcl.init] for direct-initialization.

The invocation of the allocation function is sequenced before the evaluations of expressions in the new-initializer.

Initialization of the allocated object is sequenced before the value computation of the new-expression.

If the new-expression creates an array of objects of class type, the destructor is potentially invoked ([class.dtor]).

If any part of the object initialization described above61 terminates by throwing an exception and a suitable deallocation function can be found, the deallocation function is called to free the memory in which the object was being constructed, after which the exception continues to propagate in the context of the new-expression.

If no unambiguous matching deallocation function can be found, propagating the exception does not cause the object's memory to be freed.

If the new-expression does not begin with a unary ​::​ operator and the allocated type is a class type T or an array thereof, a search is performed for the deallocation function's name in the scope of T.

Otherwise, or if nothing is found, the deallocation function's name is looked up by searching for it in the global scope.

A declaration of a placement deallocation function matches the declaration of a placement allocation function if it has the same number of parameters and, after parameter transformations ([dcl.fct]), all parameter types except the first are identical.

If the lookup finds a single matching deallocation function, that function will be called; otherwise, no deallocation function will be called.

If the lookup finds a usual deallocation function and that function, considered as a placement deallocation function, would have been selected as a match for the allocation function, the program is ill-formed.

For a non-placement allocation function, the normal deallocation function lookup is used to find the matching deallocation function ([expr.delete]).

In any case, the matching deallocation function (if any) shall be non-deleted and accessible from the point where the new-expression appears.

If a new-expression calls a deallocation function, it passes the value returned from the allocation function call as the first argument of type void*.

If a placement deallocation function is called, it is passed the same additional arguments as were passed to the placement allocation function, that is, the same arguments as those specified with the new-placement syntax.

If the implementation is allowed to introduce a temporary object or make a copy of any argument as part of the call to the allocation function, it is unspecified whether the same object is used in the call to both the allocation and deallocation functions.

The delete-expression operator destroys a most derived object or array created by a new-expression.

The first alternative is a single-object delete expression, and the second is an array delete expression.

Whenever the delete keyword is immediately followed by empty square brackets, it shall be interpreted as the second alternative.62

If the operand is of class type, it is contextually implicitly converted ([conv]) to a pointer to object type and the converted operand is used in place of the original operand for the remainder of this subclause.

Otherwise, it shall be a prvalue of pointer to object type.

The delete-expression has type void.

In a single-object delete expression, the value of the operand of delete may be a null pointer value, a pointer value that resulted from a previous non-array new-expression, or a pointer to a base class subobject of an object created by such a new-expression.

If not, the behavior is undefined.

In an array delete expression, the value of the operand of delete may be a null pointer value or a pointer value that resulted from a previous array new-expression whose allocation function was not a non-allocating form ([new.delete.placement]).63

If not, the behavior is undefined.

In a single-object delete expression, if the static type of the object to be deleted is not similar ([conv.qual]) to its dynamic type and the selected deallocation function (see below) is not a destroying operator delete, the static type shall be a base class of the dynamic type of the object to be deleted and the static type shall have a virtual destructor or the behavior is undefined.

In an array delete expression, if the dynamic type of the object to be deleted is not similar to its static type, the behavior is undefined.

If the object being deleted has incomplete class type at the point of deletion, the program is ill-formed.

If the value of the operand of the delete-expression is not a null pointer value and the selected deallocation function (see below) is not a destroying operator delete, evaluating the delete-expression invokes the destructor (if any) for the object or the elements of the array being deleted.