[expr.compound] - C++17 → C++20

Files changed (1) hide show

tmp/tmphx1at_bo/{from.md → to.md} +2880 -0

tmp/tmphx1at_bo/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,2880 @@

+## Compound expressions <a id="expr.compound">[[expr.compound]]</a>
+### Postfix expressions <a id="expr.post">[[expr.post]]</a>
+Postfix expressions group left-to-right.
+``` bnf
+postfix-expression:
+    primary-expression
+    postfix-expression '[' expr-or-braced-init-list ']'
+    postfix-expression '(' expression-listₒₚₜ ')'
+    simple-type-specifier '(' expression-listₒₚₜ ')'
+    typename-specifier '(' expression-listₒₚₜ ')'
+    simple-type-specifier braced-init-list
+    typename-specifier braced-init-list
+    postfix-expression '.' 'template'ₒₚₜ id-expression
+    postfix-expression '->' 'template'ₒₚₜ id-expression
+    postfix-expression '++'
+    postfix-expression '-{-}'
+    dynamic_cast '<' type-id '>' '(' expression ')'
+    static_cast '<' type-id '>' '(' expression ')'
+    reinterpret_cast '<' type-id '>' '(' expression ')'
+    const_cast '<' type-id '>' '(' expression ')'
+    typeid '(' expression ')'
+    typeid '(' type-id ')'
+```
+``` bnf
+expression-list:
+    initializer-list
+```
+[*Note 1*: The `>` token following the *type-id* in a `dynamic_cast`,
+`static_cast`, `reinterpret_cast`, or `const_cast` may be the product of
+replacing a `>{>}` token by two consecutive `>` tokens
+[[temp.names]]. — *end note*]
+#### Subscripting <a id="expr.sub">[[expr.sub]]</a>
+A postfix expression followed by an expression in square brackets is a
+postfix 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.[^11] 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. The
+expression `E1` is sequenced before the expression `E2`.
+[*Note 1*: A comma expression [[expr.comma]] appearing as the
+*expr-or-braced-init-list* of a subscripting expression is deprecated;
+see [[depr.comma.subscript]]. — *end note*]
+[*Note 2*: Despite its asymmetric appearance, subscripting is a
+commutative operation except for sequencing. See  [[expr.unary]] and
+[[expr.add]] for details of `*` and `+` and  [[dcl.array]] for details
+of array types. — *end note*]
+A *braced-init-list* shall not be used with the built-in subscript
+operator.
+#### Function call <a id="expr.call">[[expr.call]]</a>
+A function call is a postfix expression followed by parentheses
+containing a possibly empty, comma-separated list of
+*initializer-clause*s which constitute the arguments to the function.
+[*Note 1*: If the postfix expression is a function or member function
+name, the appropriate function and the validity of the call are
+determined according to the rules in  [[over.match]]. — *end note*]
+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 either be 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 have function
+pointer type.
+For a call to a non-static member function, the postfix expression shall
+be an implicit ([[class.mfct.non-static]], [[class.static]]) or
+explicit class member access [[expr.ref]] whose *id-expression* is a
+function member name, or a pointer-to-member expression
+[[expr.mptr.oper]] selecting a function member; the call is as a member
+of the class object referred to by the object expression. In the case of
+an implicit class member access, the implied object is the one pointed
+to by `this`.
+[*Note 2*: A member function call of the form `f()` is interpreted as
+`(*this).f()` (see  [[class.mfct.non-static]]). — *end note*]
+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 [[class.virtual]] in the dynamic
+type of the object expression is called; such a call is referred to as a
+*virtual function call*.
+[*Note 3*: The dynamic type is the type of the object referred to by
+the current value of the object expression. [[class.cdtor]] describes
+the behavior of virtual function calls when the object expression refers
+to an object under construction or destruction. — *end note*]
+[*Note 4*: If a function or member function name is used, and name
+lookup [[basic.lookup]] does not find a declaration of that name, the
+program is ill-formed. No function is implicitly declared by such a
+call. — *end note*]
+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. This return type shall be an object type, a reference type or
+cv `void`. 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]]).
+Calling a function through an expression whose function type is
+different from the function 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
+there is no corresponding argument, the default argument for the
+parameter is used.
+[*Example 1*:
+``` cpp
+template<typename ...T> int f(int n = 0, T ...t);
+int x = f<int>();               // error: no argument for second function parameter
+```
+— *end example*]
+If the function is a non-static member function, the `this` parameter of
+the function [[class.this]] is initialized with a pointer to the object
+of the call, converted as if by an explicit type conversion
+[[expr.cast]].
+[*Note 5*: There is no access or ambiguity checking on this conversion;
+the access checking and disambiguation are done as part of the (possibly
+implicit) class member access operator. See  [[class.member.lookup]],
+[[class.access.base]], and  [[expr.ref]]. — *end note*]
+When a function is called, the type of any parameter shall not be a
+class type that is either incomplete or abstract.
+[*Note 6*: This still allows a parameter to be a pointer or reference
+to such a type. However, it prevents a passed-by-value parameter to have
+an incomplete or abstract class type. — *end note*]
+It is *implementation-defined* whether the lifetime of a parameter ends
+when the function in which it is defined returns or at the end of the
+enclosing full-expression. The initialization and destruction of each
+parameter occurs within the context of the calling function.
+[*Example 2*: The access of the constructor, conversion functions or
+destructor is checked at the point of call in the calling function. If a
+constructor or destructor for a function parameter throws an exception,
+the search for a handler starts in the scope of the calling function; in
+particular, if the function called has a *function-try-block*
+[[except.pre]] with a handler that could handle the exception, this
+handler is not considered. — *end example*]
+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.
+[*Note 7*: All side effects of argument evaluations are sequenced
+before the function is entered (see
+[[intro.execution]]). — *end note*]
+[*Example 3*:
+``` cpp
+void f() {
+  std::string s = "but I have heard it works even if you don't believe in it";
+  s.replace(0, 4, "").replace(s.find("even"), 4, "only").replace(s.find(" don't"), 6, "");
+  assert(s == "I have heard it works only if you believe in it");       // OK
+}
+```
+— *end example*]
+[*Note 8*: If an operator function is invoked using operator notation,
+argument evaluation is sequenced as specified for the built-in operator;
+see  [[over.match.oper]]. — *end note*]
+[*Example 4*:
+``` cpp
+struct S {
+  S(int);
+};
+int operator<<(S, int);
+int i, j;
+int x = S(i=1) << (i=2);
+int y = operator<<(S(j=1), j=2);
+```
+After performing the initializations, the value of `i` is 2 (see
+[[expr.shift]]), but it is unspecified whether the value of `j` is 1 or
+2.
+— *end example*]
+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.
+[*Note 9*:  A function can change the values of its non-const
+parameters, but these changes cannot affect the values of the arguments
+except where a parameter is of a reference type [[dcl.ref]]; if the
+reference is to a const-qualified type, `const_cast` is required to be
+used to cast away the constness in order to modify the argument’s value.
+Where a parameter is of `const` reference type a temporary object is
+introduced if needed ([[dcl.type]], [[lex.literal]], [[lex.string]],
+[[dcl.array]], [[class.temporary]]). In addition, it is possible to
+modify the values of non-constant objects through pointer
+parameters. — *end note*]
+A function can be declared to accept fewer arguments (by declaring
+default arguments [[dcl.fct.default]]) or more arguments (by using the
+ellipsis, `...`, or a function parameter pack [[dcl.fct]]) than the
+number of parameters in the function definition [[dcl.fct.def]].
+[*Note 10*: This implies that, except where the ellipsis (`...`) or a
+function parameter pack is used, a parameter is available for each
+argument. — *end note*]
+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` [[support.runtime]].
+[*Note 11*: This paragraph does not apply to arguments passed to a
+function parameter pack. Function parameter packs are expanded during
+template instantiation [[temp.variadic]], thus each such argument has a
+corresponding parameter when a function template specialization is
+actually called. — *end note*]
+The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
+function-to-pointer [[conv.func]] 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 or of a
+class type [[class]] having an eligible non-trivial copy constructor, an
+eligible non-trivial move constructor, or a non-trivial destructor
+[[special]], 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
+[[conv.prom]], or a floating-point type that is subject to the
+floating-point promotion [[conv.fpprom]], 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
+[[basic.start.main]].
+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.
+#### Explicit type conversion (functional notation) <a id="expr.type.conv">[[expr.type.conv]]</a>
+A *simple-type-specifier* [[dcl.type.simple]] or *typename-specifier*
+[[temp.res]] 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
+[[over.match.class.deduct]] for the remainder of this subclause.
+If the initializer is a parenthesized single expression, the type
+conversion expression is equivalent to the corresponding cast expression
+[[expr.cast]]. Otherwise, if the type is cv `void` and the initializer
+is `()` or `{}` (after pack expansion, if any), the expression is a
+prvalue of the specified type that performs no initialization.
+Otherwise, the expression is a prvalue of the specified type whose
+result object is direct-initialized [[dcl.init]] with the initializer.
+If the initializer is a parenthesized optional *expression-list*, the
+specified type shall not be an array type.
+#### Class member access <a id="expr.ref">[[expr.ref]]</a>
+A postfix expression followed by a dot `.` or an arrow `->`, optionally
+followed by the keyword `template` [[temp.names]], and then followed by
+an *id-expression*, is a postfix expression. The postfix expression
+before the dot or arrow is evaluated;[^12] the result of that
+evaluation, together with the *id-expression*, determines the result of
+the entire postfix expression.
+For the first option (dot) 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).[^13]
+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 an lvalue of type “function of ()
+returning `void`”.
+[*Note 1*: This value can only be used for a notional function call
+[[expr.prim.id.dtor]]. — *end note*]
+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.
+[*Note 2*: If the class is incomplete, lookup in the complete class
+type is required to refer to the same declaration
+[[basic.scope.class]]. — *end note*]
+The *id-expression* shall name a member of the class or of one of its
+base classes.
+[*Note 3*: Because the name of a class is inserted in its class scope
+[[class]], the name of a class is also considered a nested member of
+that class. — *end note*]
+[*Note 4*:  [[basic.lookup.classref]] describes how names are looked up
+after the `.` and `->` operators. — *end note*]
+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; the type of `E1.E2` is `T`. Otherwise, one of the following
+rules applies.
+- If `E2` is a static data member and the type of `E2` is `T`, then
+  `E1.E2` is an lvalue; the expression designates the named member of
+  the class. The type of `E1.E2` is `T`.
+- If `E2` is a non-static data member and the type of `E1` is “*cq1 vq1*
+  `X`”, and the type of `E2` is “*cq2 vq2* `T`”, the expression
+  designates the corresponding member subobject of the object designated
+  by the first expression. If `E1` is an lvalue, then `E1.E2` is an
+  lvalue; otherwise `E1.E2` is an xvalue. Let the notation *vq12* stand
+  for the “union” of *vq1* and *vq2*; that is, if *vq1* or *vq2* is
+  `volatile`, then *vq12* is `volatile`. Similarly, let the notation
+  *cq12* stand for the “union” of *cq1* and *cq2*; that is, if *cq1* or
+  *cq2* is `const`, then *cq12* is `const`. If `E2` is declared to be a
+  `mutable` member, then the type of `E1.E2` is “*vq12* `T`”. If `E2` is
+  not declared to be a `mutable` member, then the type of `E1.E2` is
+  “*cq12* *vq12* `T`”.
+- If `E2` is a (possibly overloaded) member function, function overload
+  resolution [[over.match]] is used to select the function to which `E2`
+  refers. The type of `E1.E2` is the type of `E2` and `E1.E2` refers to
+  the function referred to by `E2`.
+  - If `E2` refers to a static member function, `E1.E2` is an lvalue.
+  - Otherwise (when `E2` refers to a non-static member function),
+    `E1.E2` is a prvalue. The expression can be used only as the
+    left-hand operand of a member function call [[class.mfct]].
+    \[*Note 5*: Any redundant set of parentheses surrounding the
+    expression is ignored [[expr.prim.paren]]. — *end note*]
+- If `E2` is a nested type, the expression `E1.E2` is ill-formed.
+- If `E2` is a member enumerator and the type of `E2` is `T`, the
+  expression `E1.E2` is a prvalue. The type of `E1.E2` is `T`.
+If `E2` is a non-static data member or a non-static member function, 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`.
+[*Note 6*: The program is also ill-formed if the naming class is an
+ambiguous base of the class type of the object expression; see
+[[class.access.base]]. — *end note*]
+#### Increment and decrement <a id="expr.post.incr">[[expr.post.incr]]</a>
+The value of a postfix `++` expression is the value of its operand.
+[*Note 1*: The value obtained is a copy of the original
+value. — *end note*]
+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]] by adding `1` to it. 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.
+[*Note 2*: Therefore, a function call cannot intervene between the
+lvalue-to-rvalue conversion and the side effect associated with any
+single postfix `++` operator. — *end note*]
+The result is a prvalue. The type of the result is the cv-unqualified
+version of the type of the operand. If the operand is a bit-field that
+cannot represent the incremented value, the resulting value of the
+bit-field is *implementation-defined*. See also  [[expr.add]] and
+[[expr.ass]].
+The operand of postfix `\dcr` is decremented analogously to the postfix
+`++` operator.
+[*Note 3*: For prefix increment and decrement, see
+[[expr.pre.incr]]. — *end note*]
+#### Dynamic cast <a id="expr.dynamic.cast">[[expr.dynamic.cast]]</a>
+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`.[^14] In both the pointer and reference cases,
+the program is ill-formed if `B` is an inaccessible or ambiguous base
+class of `D`.
+[*Example 1*:
+``` cpp
+struct B { };
+struct D : B { };
+void foo(D* dp) {
+  B*  bp = dynamic_cast<B*>(dp);    // equivalent to B* bp = dp;
+}
+```
+— *end example*]
+Otherwise, `v` shall be a pointer to or a glvalue of a polymorphic type
+[[class.virtual]].
+If `v` is a null pointer value, the result is a null pointer value.
+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`.
+If `C` is the class type to which `T` points or refers, the runtime
+check logically executes as follows:
+- 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.
+- 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.
+- 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 [[except.throw]] of a type that would match a handler
+[[except.handle]] of type `std::bad_cast` [[bad.cast]].
+[*Example 2*:
+``` cpp
+class A { virtual void f(); };
+class B { virtual void g(); };
+class D : public virtual A, private B { };
+void g() {
+  D   d;
+  B*  bp = (B*)&d;                  // cast needed to break protection
+  A*  ap = &d;                      // public derivation, no cast needed
+  D&  dr = dynamic_cast<D&>(*bp);   // fails
+  ap = dynamic_cast<A*>(bp);        // fails
+  bp = dynamic_cast<B*>(ap);        // fails
+  ap = dynamic_cast<A*>(&d);        // succeeds
+  bp = dynamic_cast<B*>(&d);        // ill-formed (not a runtime check)
+}
+class E : public D, public B { };
+class F : public E, public D { };
+void h() {
+  F   f;
+  A*  ap  = &f;                     // succeeds: finds unique A
+  D*  dp  = dynamic_cast<D*>(ap);   // fails: yields null; f has two D subobjects
+  E*  ep  = (E*)ap;                 // error: cast from virtual base
+  E*  ep1 = dynamic_cast<E*>(ap);   // succeeds
+}
+```
+— *end example*]
+[*Note 1*: Subclause [[class.cdtor]] describes the behavior of a
+`dynamic_cast` applied to an object under construction or
+destruction. — *end note*]
+#### Type identification <a id="expr.typeid">[[expr.typeid]]</a>
+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]].[^15] 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.
+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. If the glvalue is
+obtained by applying the unary `*` operator to a pointer[^16] and the
+pointer is 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` exception [[bad.typeid]].
+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
+[[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
+[[conv.func]] conversions are not applied to the expression. If the
+expression is a prvalue, the temporary materialization conversion
+[[conv.rval]] is applied. The expression is an unevaluated operand
+[[expr.prop]].
+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 *type-id* is a class type or a reference to a class type, the class
+shall be completely-defined.
+[*Note 1*: The *type-id* cannot denote a function type with a
+*cv-qualifier-seq* or a *ref-qualifier* [[dcl.fct]]. — *end note*]
+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.
+[*Example 1*:
+``` cpp
+class D { ... };
+D d1;
+const D d2;
+typeid(d1) == typeid(d2);       // yields true
+typeid(D)  == typeid(const D);  // yields true
+typeid(D)  == typeid(d2);       // yields true
+typeid(D)  == typeid(const D&); // yields true
+```
+— *end example*]
+If the header `<typeinfo>` is not imported or included prior to a use of
+`typeid`, the program is ill-formed.
+[*Note 2*: Subclause [[class.cdtor]] describes the behavior of `typeid`
+applied to an object under construction or destruction. — *end note*]
+#### Static cast <a id="expr.static.cast">[[expr.static.cast]]</a>
+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 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.
+[*Example 1*:
+``` cpp
+struct B { };
+struct D : public B { };
+D d;
+B &br = d;
+static_cast<D&>(br);            // produces lvalue denoting the original d object
+```
+— *end example*]
+An lvalue of type “*cv1* `T1`” can be cast to type “rvalue reference to
+*cv2* `T2`” if “*cv2* `T2`” is reference-compatible with “*cv1* `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 [[conv.lval]] is applied to the bit-field
+and the resulting prvalue is used as the *expression* 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.
+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
+``` cpp
+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.
+[*Note 1*: The conversion is ill-formed when attempting to convert an
+expression of class type to an inaccessible or ambiguous base
+class. — *end note*]
+[*Note 2*: If `T` is “array of unknown bound of `U`”, this
+direct-initialization defines the type of the expression as
+`U[1]`. — *end note*]
+Otherwise, the `static_cast` shall perform one of the conversions listed
+below. No other conversion shall be performed explicitly using a
+`static_cast`.
+Any expression can be explicitly converted to type cv `void`, in which
+case it becomes a discarded-value expression [[expr.prop]].
+[*Note 3*: However, if the value is in a temporary object
+[[class.temporary]], the destructor for that object is not executed
+until the usual time, and the value of the object is preserved for the
+purpose of executing the destructor. — *end note*]
+The inverse of any 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.
+[*Example 2*:
+``` cpp
+struct B { };
+struct D : private B { };
+void f() {
+  static_cast<D*>((B*)0);               // error: B is a private base of D
+  static_cast<int B::*>((int D::*)0);   // error: B is a private base of D
+}
+```
+— *end example*]
+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
+conversion, 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 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 [[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 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
+[[class.derived]] of `D`, if *cv2* is the same cv-qualification as, or
+greater cv-qualification than, *cv1*.
+[*Note 4*: Function types (including those used in
+pointer-to-member-function types) are never cv-qualified
+[[dcl.fct]]. — *end note*]
+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 [[conv.mem]] is
+converted to the null member pointer value of the destination type. If
+class `B` contains the original member, or is a base or derived class of
+the class containing the original member, the resulting pointer to
+member points to the original member. Otherwise, the behavior is
+undefined.
+[*Note 5*: Although class `B` need not contain the original member, the
+dynamic type of the object with which indirection through the pointer to
+member is performed must contain the original member; see
+[[expr.mptr.oper]]. — *end note*]
+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 is unspecified. Otherwise, if the
+original pointer value points to an object *a*, and there is an object
+*b* of type `T` (ignoring cv-qualification) that is
+pointer-interconvertible [[basic.compound]] with *a*, the result is a
+pointer to *b*. Otherwise, the pointer value is unchanged by the
+conversion.
+[*Example 3*:
+``` cpp
+T* p1 = new T;
+const T* p2 = static_cast<const T*>(static_cast<void*>(p1));
+bool b = p1 == p2;  // b will have the value true.
+```
+— *end example*]
+#### Reinterpret cast <a id="expr.reinterpret.cast">[[expr.reinterpret.cast]]</a>
+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
+[[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
+[[conv.func]] 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.
+[*Note 1*: The mapping performed by `reinterpret_cast` might, or might
+not, produce a representation different from the original
+value. — *end note*]
+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*.
+[*Note 2*: It is intended to be unsurprising to those who know the
+addressing structure of the underlying machine. — *end note*]
+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.
+[*Note 3*: A `reinterpret_cast` cannot be used to convert a value of
+any type to the type `std::nullptr_t`. — *end note*]
+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; mappings between pointers and integers are
+otherwise *implementation-defined*.
+[*Note 4*: Except as described in [[basic.stc.dynamic.safety]], the
+result of such a conversion will not be a safely-derived pointer
+value. — *end note*]
+A function pointer can be explicitly converted to a function pointer of
+a different type.
+[*Note 5*: The effect of calling a function through a pointer to a
+function type [[dcl.fct]] that is not the same as the type used in the
+definition of the function is undefined [[expr.call]]. — *end note*]
+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.
+[*Note 6*: See also  [[conv.ptr]] for more details of pointer
+conversions. — *end note*]
+An object pointer can be explicitly converted to an object pointer of a
+different type.[^17] 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))`.
+[*Note 7*: Converting a prvalue of type “pointer to `T1`” to the type
+“pointer to `T2`” (where `T1` and `T2` are object types and where the
+alignment requirements of `T2` are no stricter than those of `T1`) and
+back to its original type yields the original pointer
+value. — *end note*]
+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.
+[*Note 8*: A null pointer constant of type `std::nullptr_t` cannot be
+converted to a pointer type, and a null pointer constant of integral
+type is not necessarily converted to a null pointer
+value. — *end note*]
+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.[^18] 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:
+- 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.
+- 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 *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. [^19]
+#### Const cast <a id="expr.const.cast">[[expr.const.cast]]</a>
+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
+[[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
+[[conv.func]] 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`.
+[*Note 1*: Subject to the restrictions in this subclause, an expression
+may be cast to its own type using a `const_cast`
+operator. — *end note*]
+For two similar types `T1` and `T2` [[conv.qual]], a prvalue of type
+`T1` may be explicitly converted to the type `T2` using a `const_cast`
+if, considering the cv-decompositions of both types, each P¹ᵢ is the
+same as P²ᵢ for all i. The result of a `const_cast` refers to the
+original entity.
+[*Example 1*:
+``` cpp
+typedef int *A[3];                  // array of 3 pointer to int
+typedef const int *const CA[3];     // array of 3 const pointer to const int
+CA &&r = A{};                       // OK, reference binds to temporary array object
+                                    // after qualification conversion to type CA
+A &&r1 = const_cast<A>(CA{});       // error: temporary array decayed to pointer
+A &&r2 = const_cast<A&&>(CA{});     // OK
+```
+— *end example*]
+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:
+- an lvalue of type `T1` can be explicitly converted to an lvalue of
+  type `T2` using the cast `const_cast<T2&>`;
+- a glvalue of type `T1` can be explicitly converted to an xvalue of
+  type `T2` using the cast `const_cast<T2&&>`; and
+- 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 [[conv.rval]] 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.
+[*Note 2*: Depending on the type of the object, a write operation
+through the pointer, lvalue or pointer to data member resulting from a
+`const_cast` that casts away a const-qualifier[^20] may produce
+undefined behavior [[dcl.type.cv]]. — *end note*]
+A conversion from a type `T1` to a type `T2` *casts away constness* if
+`T1` and `T2` are different, there is a cv-decomposition [[conv.qual]]
+of `T1` yielding *n* such that `T2` has a cv-decomposition of the form
+and there is no qualification conversion that converts `T1` to
+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.
+[*Note 3*: Some conversions which involve only changes in
+cv-qualification cannot be done using `const_cast.` For instance,
+conversions between pointers to functions are not covered because such
+conversions lead to values whose use causes undefined behavior. For the
+same reasons, conversions between pointers to member functions, and in
+particular, the conversion from a pointer to a const member function to
+a pointer to a non-const member function, are not
+covered. — *end note*]
+### Unary expressions <a id="expr.unary">[[expr.unary]]</a>
+Expressions with unary operators group right-to-left.
+``` bnf
+unary-expression:
+    postfix-expression
+    unary-operator cast-expression
+    '++' cast-expression
+    '-{-}' cast-expression
+    await-expression
+    sizeof unary-expression
+    sizeof '(' type-id ')'
+    sizeof '...' '(' identifier ')'
+    alignof '(' type-id ')'
+    noexcept-expression
+    new-expression
+    delete-expression
+```
+``` bnf
+unary-operator: one of
+    '* & + - ! ~'
+```
+#### Unary operators <a id="expr.unary.op">[[expr.unary.op]]</a>
+The unary `*` operator performs *indirection*: the expression to which
+it is applied shall be a pointer to an object type, or a pointer to a
+function type and the result is an lvalue referring to the object or
+function to which the expression points. If the type of the expression
+is “pointer to `T`”, the type of the result is “`T`”.
+[*Note 1*:  Indirection through a pointer to an incomplete type (other
+than cv `void`) is valid. The lvalue thus obtained can be used in
+limited ways (to initialize a reference, for example); this lvalue must
+not be converted to a prvalue, see  [[conv.lval]]. — *end note*]
+The result of each of the following unary operators is a prvalue.
+The result of the unary `&` operator is a pointer to its operand.
+- If the operand is a *qualified-id* naming a non-static or variant
+  member `m` of some class `C` with type `T`, the result has type
+  “pointer to member of class `C` of type `T`” and is a prvalue
+  designating `C::m`.
+- Otherwise, if the operand is an lvalue of type `T`, the resulting
+  expression is a prvalue of type “pointer to `T`” whose result is a
+  pointer to the designated object [[intro.memory]] or function.
+  \[*Note 2*: In particular, taking the address of a variable of type
+  “cv `T`” yields a pointer of type “pointer to cv `T`”. — *end note*]
+- Otherwise, the program is ill-formed.
+[*Example 1*:
+``` cpp
+struct A { int i; };
+struct B : A { };
+... &B::i ...       // has type int A::*
+int a;
+int* p1 = &a;
+int* p2 = p1 + 1;   // defined behavior
+bool b = p2 > p1;   // defined behavior, with value true
+```
+— *end example*]
+[*Note 3*: A pointer to member formed from a `mutable` non-static data
+member [[dcl.stc]] does not reflect the `mutable` specifier associated
+with the non-static data member. — *end note*]
+A pointer to member is only formed when an explicit `&` is used and its
+operand is a *qualified-id* not enclosed in parentheses.
+[*Note 4*: That is, the expression `&(qualified-id)`, where the
+*qualified-id* is enclosed in parentheses, does not form an expression
+of type “pointer to member”. Neither does `qualified-id`, because there
+is no implicit conversion from a *qualified-id* for a non-static member
+function to the type “pointer to member function” as there is from an
+lvalue of function type to the type “pointer to function” [[conv.func]].
+Nor is `&unqualified-id` a pointer to member, even within the scope of
+the *unqualified-id*’s class. — *end note*]
+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.
+[*Note 5*: The address of an overloaded function [[over]] can be taken
+only in a context that uniquely determines which version of the
+overloaded function is referred to (see  [[over.over]]). Since the
+context might determine whether the operand is a static or non-static
+member function, the context can also affect whether the expression has
+type “pointer to function” or “pointer to member
+function”. — *end note*]
+The operand of the unary `+` operator shall have 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 have arithmetic or unscoped
+enumeration type and the result is the negation 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ⁿ,
+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 `~` shall have integral or unscoped enumeration type; the
+result is the ones’ complement of its operand. Integral promotions are
+performed. The type of the result is the type of the promoted operand.
+There is an ambiguity in the grammar when `~` is followed by a
+*type-name* or *decltype-specifier*. The ambiguity is resolved by
+treating `~` as the unary complement operator rather than as the start
+of an *unqualified-id* naming a destructor.
+[*Note 6*: Because the grammar does not permit an operator to follow
+the `.`, `->`, or `::` tokens, a `~` followed by a *type-name* or
+*decltype-specifier* in a member access expression or *qualified-id* is
+unambiguously parsed as a destructor name. — *end note*]
+#### Increment and decrement <a id="expr.pre.incr">[[expr.pre.incr]]</a>
+The operand of prefix `++` is modified [[defns.access]] by adding `1`.
+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
+completely-defined object type. An operand with volatile-qualified type
+is deprecated; see  [[depr.volatile.type]]. The result is the updated
+operand; it is an lvalue, and it is a bit-field if the operand is a
+bit-field. The expression `++x` is equivalent to `x+=1`.
+[*Note 1*: See the discussions of addition [[expr.add]] and assignment
+operators [[expr.ass]] for information on conversions. — *end note*]
+The operand of prefix `\dcr` is modified [[defns.access]] by subtracting
+`1`. The requirements on the operand of prefix `\dcr` and the properties
+of its result are otherwise the same as those of prefix `++`.
+[*Note 2*: For postfix increment and decrement, see
+[[expr.post.incr]]. — *end note*]
+#### Await <a id="expr.await">[[expr.await]]</a>
+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.
+``` bnf
+await-expression:
+    'co_await' cast-expression
+```
+An *await-expression* shall appear only in a potentially-evaluated
+expression within the *compound-statement* of a *function-body* outside
+of a *handler* [[except.pre]]. In a *declaration-statement* or in the
+*simple-declaration* (if any) of a *for-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-scope
+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:
+- *p* is an lvalue naming the promise object [[dcl.fct.def.coroutine]]
+  of the enclosing coroutine and `P` is the type of that object.
+- *a* is the *cast-expression* if the *await-expression* was implicitly
+  produced by a *yield-expression* [[expr.yield]], an initial suspend
+  point, or a final suspend point [[dcl.fct.def.coroutine]]. Otherwise,
+  the *unqualified-id* `await_transform` is looked up within the scope
+  of `P` by class member access lookup [[basic.lookup.classref]], and if
+  this lookup finds at least one declaration, then *a* is
+  *p*`.await_transform(`*cast-expression*`)`; otherwise, *a* is the
+  *cast-expression*.
+- *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.
+- *e* is an lvalue referring to the result of evaluating the
+  (possibly-converted) *o*.
+- *h* is an object of type `std::coroutine_handle<P>` referring to the
+  enclosing coroutine.
+- *await-ready* is the expression *e*`.await_ready()`, contextually
+  converted to `bool`.
+- *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`.
+- *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:
+- If the result of *await-ready* is `false`, the coroutine is considered
+  suspended. Then:
+  - 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 may be successively resumed in this fashion,
+    eventually returning control flow to the current coroutine caller or
+    resumer [[dcl.fct.def.coroutine]]. — *end note*]
+  - Otherwise, if the type of *await-suspend* is `bool`, *await-suspend*
+    is evaluated, and the coroutine is resumed if the result is `false`.
+  - 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 re-thrown [[except.throw]]. Otherwise, control flow
+  returns to the current coroutine caller or resumer
+  [[dcl.fct.def.coroutine]] without exiting any scopes [[stmt.jump]].
+- If the result of *await-ready* is `true`, or when the coroutine is
+  resumed, the *await-resume* expression is evaluated, and its result is
+  the result of the *await-expression*.
+[*Example 1*:
+``` cpp
+template <typename T>
+struct my_future {
+  ...
+  bool await_ready();
+  void await_suspend(std::coroutine_handle<>);
+  T await_resume();
+};
+template <class Rep, class Period>
+auto operator co_await(std::chrono::duration<Rep, Period> d) {
+  struct awaiter {
+    std::chrono::system_clock::duration duration;
+    ...
+    awaiter(std::chrono::system_clock::duration d) : duration(d) {}
+    bool await_ready() const { return duration.count() <= 0; }
+    void await_resume() {}
+    void await_suspend(std::coroutine_handle<> h) { ... }
+  };
+  return awaiter{d};
+}
+using namespace std::chrono;
+my_future<int> h();
+my_future<void> g() {
+  std::cout << "just about go to sleep...\n";
+  co_await 10ms;
+  std::cout << "resumed\n";
+  co_await h();
+}
+auto f(int x = co_await h());   // error: await-expression outside of function suspension context
+int a[] = { co_await h() };     // error: await-expression outside of function suspension context
+```
+— *end example*]
+#### Sizeof <a id="expr.sizeof">[[expr.sizeof]]</a>
+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
+[[expr.prop]], 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*.
+[*Note 1*: In particular, `sizeof(bool)`, `sizeof(char16_t)`,
+`sizeof(char32_t)`, and `sizeof(wchar_t)` are
+implementation-defined.[^21] — *end note*]
+[*Note 2*: See  [[intro.memory]] for the definition of byte and
+[[basic.types]] for the definition of object
+representation. — *end note*]
+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. [^22] 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 [[conv.rval]] 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]].
+[*Example 1*:
+``` cpp
+template<class... Types>
+struct count {
+  static const std::size_t value = sizeof...(Types);
+};
+```
+— *end example*]
+The result of `sizeof` and `sizeof...` is a prvalue of type
+`std::size_t`.
+[*Note 3*: A `sizeof` expression is an integral constant expression
+[[expr.const]]. The type `std::size_t` is defined in the standard header
+`<cstddef>` ([[cstddef.syn]], [[support.types.layout]]). — *end note*]
+#### Alignof <a id="expr.alignof">[[expr.alignof]]</a>
+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`.
+[*Note 1*: An `alignof` expression is an integral constant expression
+[[expr.const]]. The type `std::size_t` is defined in the standard header
+`<cstddef>` ([[cstddef.syn]], [[support.types.layout]]). — *end note*]
+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.
+#### `noexcept` operator <a id="expr.unary.noexcept">[[expr.unary.noexcept]]</a>
+The `noexcept` operator determines whether the evaluation of its
+operand, which is an unevaluated operand [[expr.prop]], can throw an
+exception [[except.throw]].
+``` bnf
+noexcept-expression:
+  noexcept '(' expression ')'
+```
+The result of the `noexcept` operator is a prvalue of type `bool`.
+[*Note 1*: A *noexcept-expression* is an integral constant expression
+[[expr.const]]. — *end note*]
+The result of the `noexcept` operator is `true` unless the *expression*
+is potentially-throwing [[except.spec]].
+#### New <a id="expr.new">[[expr.new]]</a>
+The *new-expression* attempts to create an object of the *type-id*
+[[dcl.name]] or *new-type-id* to which it is applied. The type of that
+object is the *allocated type*. This type shall be a complete object
+type, but not an abstract class type or array thereof (
+[[intro.object]], [[basic.types]], [[class.abstract]]).
+[*Note 1*: Because references are not objects, references cannot be
+created by *new-expression*s. — *end note*]
+[*Note 2*: The *type-id* may be a cv-qualified type, in which case the
+object created by the *new-expression* has a cv-qualified
+type. — *end note*]
+``` bnf
+new-expression:
+    '::'ₒₚₜ new new-placementₒₚₜ new-type-id new-initializerₒₚₜ
+    '::'ₒₚₜ new new-placementₒₚₜ '(' type-id ')' new-initializerₒₚₜ
+```
+``` bnf
+new-placement:
+    '(' expression-list ')'
+```
+``` bnf
+new-type-id:
+    type-specifier-seq new-declaratorₒₚₜ
+```
+``` bnf
+new-declarator:
+    ptr-operator new-declaratorₒₚₜ
+    noptr-new-declarator
+```
+``` bnf
+noptr-new-declarator:
+    '[' expressionₒₚₜ ']' attribute-specifier-seqₒₚₜ
+    noptr-new-declarator '[' constant-expression ']' attribute-specifier-seqₒₚₜ
+```
+``` bnf
+new-initializer:
+    '(' expression-listₒₚₜ ')'
+    braced-init-list
+```
+If a placeholder type [[dcl.spec.auto]] 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]]:
+``` cpp
+T x init ;
+```
+[*Example 1*:
+``` cpp
+new auto(1);                    // allocated type is int
+auto x = new auto('a');         // allocated type is char, x is of type char*
+template<class T> struct A { A(T, T); };
+auto y = new A{1, 2};           // allocated type is A<int>
+```
+— *end example*]
+The *new-type-id* in a *new-expression* is the longest possible sequence
+of *new-declarator*s.
+[*Note 3*: This prevents ambiguities between the declarator operators
+`&`, `&&`, `*`, and `[]` and their expression
+counterparts. — *end note*]
+[*Example 2*:
+``` cpp
+new int * i;                    // syntax error: parsed as (new int*) i, not as (new int)*i
+```
+The `*` is the pointer declarator and not the multiplication operator.
+— *end example*]
+[*Note 4*:
+Parentheses in a *new-type-id* of a *new-expression* can have surprising
+effects.
+[*Example 3*:
+``` cpp
+new int(*[10])();               // error
+```
+is ill-formed because the binding is
+``` cpp
+(new int) (*[10])();            // error
+```
+Instead, the explicitly parenthesized version of the `new` operator can
+be used to create objects of compound types [[basic.compound]]:
+``` cpp
+new (int (*[10])());
+```
+allocates an array of `10` pointers to functions (taking no argument and
+returning `int`).
+— *end example*]
+— *end note*]
+Objects created by a *new-expression* have dynamic storage duration
+[[basic.stc.dynamic]].
+[*Note 5*:  The lifetime of such an object is not necessarily
+restricted to the scope in which it is created. — *end note*]
+When the allocated object is not an array, the result of the
+*new-expression* is a pointer to the object created.
+When the allocated object is an array (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 pointer to the
+initial element (if any) of the array.
+[*Note 6*: Both `new int` and `new int[10]` have type `int*` and the
+type of `new int[i][10]` is `int (*)[10]` — *end note*]
+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.
+[*Example 4*: Given the definition `int n = 42`, `new float[n][5]` is
+well-formed (because `n` is the *expression* of a
+*noptr-new-declarator*), but `new float[5][n]` is ill-formed (because
+`n` is not a constant expression). — *end example*]
+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 *expression* is erroneous if:
+- the expression is of non-class type and its value before converting to
+  `std::size_t` is less than zero;
+- the expression is of class type and its value before application of
+  the second standard conversion [[over.ics.user]][^23] is less than
+  zero;
+- its value is such that the size of the allocated object would exceed
+  the *implementation-defined* limit [[implimits]]; or
+- 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 *expression* is erroneous after converting to `std::size_t`:
+- if the *expression* is a core constant expression, the program is
+  ill-formed;
+- otherwise, an allocation function is not called; instead
+  - 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;
+  - 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` [[new.badlength]].
+When the value of the *expression* is zero, the allocation function is
+called to allocate an array with no elements.
+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
+[[basic.stc.dynamic.deallocation]]. 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[]`.
+[*Note 7*: An implementation is required to provide default definitions
+for the global allocation functions ([[basic.stc.dynamic]],
+[[new.delete.single]], [[new.delete.array]]). A C++ program can provide
+alternative definitions of these functions [[replacement.functions]]
+and/or class-specific versions [[class.free]]. The set of allocation and
+deallocation functions that may be called by a *new-expression* may
+include functions that do not perform allocation or deallocation; for
+example, see [[new.delete.placement]]. — *end note*]
+If the *new-expression* begins with a unary `::` operator, the
+allocation function’s name is looked up in the global scope. Otherwise,
+if the allocated type is a class type `T` or array thereof, the
+allocation function’s name is looked up in the scope of `T`. If this
+lookup fails to find the name, or if the allocated type is not a class
+type, the allocation function’s name is looked up 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 an allocation
+function is always omitted.
+[*Note 8*: Only *new-expression*s that would otherwise result in a call
+to a replaceable global allocation function can be evaluated in constant
+expressions [[expr.const]]. — *end note*]
+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:
+- the evaluation of `e1` is sequenced before the evaluation of `e2`, and
+- `e2` is evaluated whenever `e1` obtains storage, and
+- both `e1` and `e2` invoke the same replaceable global allocation
+  function, and
+- 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
+- the pointer values produced by `e1` and `e2` are operands to evaluated
+  *delete-expression*s, and
+- the evaluation of `e2` is sequenced before the evaluation of the
+  *delete-expression* whose operand is the pointer value produced by
+  `e1`.
+[*Example 5*:
+``` cpp
+void can_merge(int x) {
+  // These allocations are safe for merging:
+  std::unique_ptr<char[]> a{new (std::nothrow) char[8]};
+  std::unique_ptr<char[]> b{new (std::nothrow) char[8]};
+  std::unique_ptr<char[]> c{new (std::nothrow) char[x]};
+  g(a.get(), b.get(), c.get());
+}
+void cannot_merge(int x) {
+  std::unique_ptr<char[]> a{new char[8]};
+  try {
+    // Merging this allocation would change its catch handler.
+    std::unique_ptr<char[]> b{new char[x]};
+  } catch (const std::bad_alloc& e) {
+    std::cerr << "Allocation failed: " << e.what() << std::endl;
+    throw;
+  }
+}
+```
+— *end example*]
+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 [[basic.align]] of any object type
+whose size is no greater than the size of the array being created.
+[*Note 9*:  Because allocation functions are assumed to return pointers
+to storage that is appropriately aligned for objects of any type with
+fundamental alignment, this constraint on array allocation overhead
+permits the common idiom of allocating character arrays into which
+objects of other types will later be placed. — *end note*]
+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-clause*s in its *expression-list* are
+the succeeding arguments. If no matching function is found then
+- if the allocated object type has new-extended alignment, the alignment
+  argument is removed from the argument list;
+- 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.
+[*Example 6*:
+- `new T` results in one of the following calls:
+  ``` cpp
+  operator new(sizeof(T))
+  operator new(sizeof(T), std::align_val_t(alignof(T)))
+  ```
+- `new(2,f) T` results in one of the following calls:
+  ``` cpp
+  operator new(sizeof(T), 2, f)
+  operator new(sizeof(T), std::align_val_t(alignof(T)), 2, f)
+  ```
+- `new T[5]` results in one of the following calls:
+  ``` cpp
+  operator new[](sizeof(T) * 5 + x)
+  operator new[](sizeof(T) * 5 + x, std::align_val_t(alignof(T)))
+  ```
+- `new(2,f) T[5]` results in one of the following calls:
+  ``` cpp
+  operator new[](sizeof(T) * 5 + x, 2, f)
+  operator new[](sizeof(T) * 5 + x, std::align_val_t(alignof(T)), 2, f)
+  ```
+Here, each instance of `x` is a non-negative unspecified value
+representing array allocation overhead; the result of the
+*new-expression* will be offset by this amount from the value returned
+by `operator new[]`. This overhead may be applied in all array
+*new-expression*s, including those referencing a placement allocation
+function, except when referencing the library function
+`operator new[](std::size_t, void*)`. The amount of overhead may vary
+from one invocation of `new` to another.
+— *end example*]
+[*Note 10*: Unless an allocation function has a non-throwing exception
+specification [[except.spec]], it indicates failure to allocate storage
+by throwing a `std::bad_alloc` exception (
+[[basic.stc.dynamic.allocation]], [[except]], [[bad.alloc]]); it returns
+a non-null pointer otherwise. If the allocation function has a
+non-throwing exception specification, it returns null to indicate
+failure to allocate storage and a non-null pointer
+otherwise. — *end note*]
+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.
+[*Note 11*: When the allocation function returns a value other than
+null, it must be a pointer to a block of storage in which space for the
+object has been reserved. The block of storage is assumed to be
+appropriately aligned and of the requested size. The address of the
+created object will not necessarily be the same as that of the block if
+the object is an array. — *end note*]
+A *new-expression* that creates an object of type `T` initializes that
+object as follows:
+- 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*]
+- 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 object or an array of objects of
+class type, access and ambiguity control are done for the allocation
+function, the deallocation function [[class.free]], and the constructor
+[[class.ctor]] selected for the initialization (if any). 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 above[^24] 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.
+[*Note 13*: This is appropriate when the called allocation function
+does not allocate memory; otherwise, it is likely to result in a memory
+leak. — *end note*]
+If the *new-expression* begins with a unary `::` operator, the
+deallocation function’s name is looked up in the global scope.
+Otherwise, if the allocated type is a class type `T` or an array
+thereof, the deallocation function’s name is looked up in the scope of
+`T`. If this lookup fails to find the name, or if the allocated type is
+not a class type or array thereof, the deallocation function’s name is
+looked up 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]].
+[*Example 7*:
+``` cpp
+struct S {
+  // Placement allocation function:
+  static void* operator new(std::size_t, std::size_t);
+  // Usual (non-placement) deallocation function:
+  static void operator delete(void*, std::size_t);
+};
+S* p = new (0) S;   // error: non-placement deallocation function matches
+                    // placement allocation function
+```
+— *end example*]
+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.
+#### Delete <a id="expr.delete">[[expr.delete]]</a>
+The *delete-expression* operator destroys a most derived object
+[[intro.object]] or array created by a *new-expression*.
+``` bnf
+delete-expression:
+    '::'ₒₚₜ delete cast-expression
+    '::'ₒₚₜ delete '[' ']' cast-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.[^25] The operand shall be of pointer to
+object type or of class type. If of class type, the operand is
+contextually implicitly converted [[conv]] to a pointer to object
+type.[^26] The *delete-expression*’s result has type `void`.
+If the operand has a class type, the operand is converted to a pointer
+type by calling the above-mentioned conversion function, and the
+converted operand is used in place of the original operand for the
+remainder of this subclause. In a single-object delete expression, the
+value of the operand of `delete` may be a null pointer value, a pointer
+to a non-array object created by a previous *new-expression*, or a
+pointer to a subobject [[intro.object]] representing a base class of
+such an object [[class.derived]]. 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*.[^27] If not, the behavior is undefined.
+[*Note 1*: This means that the syntax of the *delete-expression* must
+match the type of the object allocated by `new`, not the syntax of the
+*new-expression*. — *end note*]
+[*Note 2*: A pointer to a `const` type can be the operand of a
+*delete-expression*; it is not necessary to cast away the constness
+[[expr.const.cast]] of the pointer expression before it is used as the
+operand of the *delete-expression*. — *end note*]
+In a single-object delete expression, if the static type of the object
+to be deleted is different from 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 differs from its static type, the
+behavior is undefined.
+The *cast-expression* in a *delete-expression* shall be evaluated
+exactly once.
+If the object being deleted has incomplete class type at the point of
+deletion and the complete class has a non-trivial destructor or a
+deallocation function, the behavior is undefined.
+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, the *delete-expression* will invoke the
+destructor (if any) for the object or the elements of the array being
+deleted. In the case of an array, the elements will be destroyed in
+order of decreasing address (that is, in reverse order of the completion
+of their constructor; see  [[class.base.init]]).
+If the value of the operand of the *delete-expression* is not a null
+pointer value, then:
+- If the allocation call for the *new-expression* for the object to be
+  deleted was not omitted and the allocation was not extended
+  [[expr.new]], the *delete-expression* shall call a deallocation
+  function [[basic.stc.dynamic.deallocation]]. The value returned from
+  the allocation call of the *new-expression* shall be passed as the
+  first argument to the deallocation function.
+- Otherwise, if the allocation was extended or was provided by extending
+  the allocation of another *new-expression*, and the
+  *delete-expression* for every other pointer value produced by a
+  *new-expression* that had storage provided by the extended
+  *new-expression* has been evaluated, the *delete-expression* shall
+  call a deallocation function. The value returned from the allocation
+  call of the extended *new-expression* shall be passed as the first
+  argument to the deallocation function.
+- Otherwise, the *delete-expression* will not call a deallocation
+  function.
+[*Note 3*: The deallocation function is called regardless of whether
+the destructor for the object or some element of the array throws an
+exception. — *end note*]
+If the value of the operand of the *delete-expression* is a null pointer
+value, it is unspecified whether a deallocation function will be called
+as described above.
+[*Note 4*: An implementation provides default definitions of the global
+deallocation functions `operator delete` for non-arrays
+[[new.delete.single]] and `operator delete[]` for arrays
+[[new.delete.array]]. A C++ program can provide alternative definitions
+of these functions [[replacement.functions]], and/or class-specific
+versions [[class.free]]. — *end note*]
+When the keyword `delete` in a *delete-expression* is preceded by the
+unary `::` operator, the deallocation function’s name is looked up in
+global scope. Otherwise, the lookup considers class-specific
+deallocation functions [[class.free]]. If no class-specific deallocation
+function is found, the deallocation function’s name is looked up in
+global scope.
+If deallocation function lookup finds more than one usual deallocation
+function, the function to be called is selected as follows:
+- If any of the deallocation functions is a destroying operator delete,
+  all deallocation functions that are not destroying operator deletes
+  are eliminated from further consideration.
+- If the type has new-extended alignment, a function with a parameter of
+  type `std::align_val_t` is preferred; otherwise a function without
+  such a parameter is preferred. If any preferred functions are found,
+  all non-preferred functions are eliminated from further consideration.
+- If exactly one function remains, that function is selected and the
+  selection process terminates.
+- If the deallocation functions have class scope, the one without a
+  parameter of type `std::size_t` is selected.
+- If the type is complete and if, for an array delete expression only,
+  the operand is a pointer to a class type with a non-trivial destructor
+  or a (possibly multi-dimensional) array thereof, the function with a
+  parameter of type `std::size_t` is selected.
+- Otherwise, it is unspecified whether a deallocation function with a
+  parameter of type `std::size_t` is selected.
+For a single-object delete expression, the deleted object is the object
+denoted by the operand if its static type does not have a virtual
+destructor, and its most-derived object otherwise.
+[*Note 5*: If the deallocation function is not a destroying operator
+delete and the deleted object is not the most derived object in the
+former case, the behavior is undefined, as stated above. — *end note*]
+For an array delete expression, the deleted object is the array object.
+When a *delete-expression* is executed, the selected deallocation
+function shall be called with the address of the deleted object in a
+single-object delete expression, or the address of the deleted object
+suitably adjusted for the array allocation overhead [[expr.new]] in an
+array delete expression, as its first argument.
+[*Note 6*: Any cv-qualifiers in the type of the deleted object are
+ignored when forming this argument. — *end note*]
+If a destroying operator delete is used, an unspecified value is passed
+as the argument corresponding to the parameter of type
+`std::destroying_delete_t`. If a deallocation function with a parameter
+of type `std::align_val_t` is used, the alignment of the type of the
+deleted object is passed as the corresponding argument. If a
+deallocation function with a parameter of type `std::size_t` is used,
+the size of the deleted object in a single-object delete expression, or
+of the array plus allocation overhead in an array delete expression, is
+passed as the corresponding argument.
+[*Note 7*: If this results in a call to a replaceable deallocation
+function, and either the first argument was not the result of a prior
+call to a replaceable allocation function or the second or third
+argument was not the corresponding argument in said call, the behavior
+is undefined ([[new.delete.single]],
+[[new.delete.array]]). — *end note*]
+Access and ambiguity control are done for both the deallocation function
+and the destructor ([[class.dtor]], [[class.free]]).
+### Explicit type conversion (cast notation) <a id="expr.cast">[[expr.cast]]</a>
+The result of the expression `(T)` *cast-expression* is of type `T`. The
+result is an lvalue if `T` is an lvalue reference type or an rvalue
+reference to function type and an xvalue if `T` is an rvalue reference
+to object type; otherwise the result is a prvalue.
+[*Note 1*: If `T` is a non-class type that is cv-qualified, the
+*cv-qualifier*s are discarded when determining the type of the resulting
+prvalue; see [[expr.prop]]. — *end note*]
+An explicit type conversion can be expressed using functional notation
+[[expr.type.conv]], a type conversion operator (`dynamic_cast`,
+`static_cast`, `reinterpret_cast`, `const_cast`), or the *cast*
+notation.
+``` bnf
+cast-expression:
+    unary-expression
+    '(' type-id ')' cast-expression
+```
+Any type conversion not mentioned below and not explicitly defined by
+the user [[class.conv]] is ill-formed.
+The conversions performed by
+- a `const_cast` [[expr.const.cast]],
+- a `static_cast` [[expr.static.cast]],
+- a `static_cast` followed by a `const_cast`,
+- a `reinterpret_cast` [[expr.reinterpret.cast]], or
+- a `reinterpret_cast` followed by a `const_cast`,
+can be performed using the cast notation of explicit type conversion.
+The same semantic restrictions and behaviors apply, with the exception
+that in performing a `static_cast` in the following situations the
+conversion is valid even if the base class is inaccessible:
+- a pointer to an object of derived class type or an lvalue or rvalue of
+  derived class type may be explicitly converted to a pointer or
+  reference to an unambiguous base class type, respectively;
+- a pointer to member of derived class type may be explicitly converted
+  to a pointer to member of an unambiguous non-virtual base class type;
+- a pointer to an object of an unambiguous non-virtual base class type,
+  a glvalue of an unambiguous non-virtual base class type, or a pointer
+  to member of an unambiguous non-virtual base class type may be
+  explicitly converted to a pointer, a reference, or a pointer to member
+  of a derived class type, respectively.
+If a conversion can be interpreted in more than one of the ways listed
+above, the interpretation that appears first in the list is used, even
+if a cast resulting from that interpretation is ill-formed. If a
+conversion can be interpreted in more than one way as a `static_cast`
+followed by a `const_cast`, the conversion is ill-formed.
+[*Example 1*:
+``` cpp
+struct A { };
+struct I1 : A { };
+struct I2 : A { };
+struct D : I1, I2 { };
+A* foo( D* p ) {
+  return (A*)( p );             // ill-formed static_cast interpretation
+}
+```
+— *end example*]
+The operand of a cast using the cast notation can be a prvalue of type
+“pointer to incomplete class type”. The destination type of a cast using
+the cast notation can be “pointer to incomplete class type”. If both the
+operand and destination types are class types and one or both are
+incomplete, it is unspecified whether the `static_cast` or the
+`reinterpret_cast` interpretation is used, even if there is an
+inheritance relationship between the two classes.
+[*Note 2*: For example, if the classes were defined later in the
+translation unit, a multi-pass compiler would be permitted to interpret
+a cast between pointers to the classes as if the class types were
+complete at the point of the cast. — *end note*]
+### Pointer-to-member operators <a id="expr.mptr.oper">[[expr.mptr.oper]]</a>
+The pointer-to-member operators `->*` and `.*` group left-to-right.
+``` bnf
+pm-expression:
+    cast-expression
+    pm-expression '.*' cast-expression
+    pm-expression '->*' cast-expression
+```
+The binary operator `.*` binds its second operand, which shall be of
+type “pointer to member of `T`” to its first operand, which shall be a
+glvalue of class `T` or of a class of which `T` is an unambiguous and
+accessible base class. The result is an object or a function of the type
+specified by the second operand.
+The binary operator `->*` binds its second operand, which shall be of
+type “pointer to member of `T`” to its first operand, which shall be of
+type “pointer to `U`” where `U` is either `T` or a class of which `T` is
+an unambiguous and accessible base class. The expression `E1->*E2` is
+converted into the equivalent form `(*(E1)).*E2`.
+Abbreviating *pm-expression*`.*`*cast-expression* as `E1.*E2`, `E1` is
+called the *object expression*. If the dynamic type of `E1` does not
+contain the member to which `E2` refers, the behavior is undefined.
+Otherwise, the expression `E1` is sequenced before the expression `E2`.
+The restrictions on cv-qualification, and the manner in which the
+cv-qualifiers of the operands are combined to produce the cv-qualifiers
+of the result, are the same as the rules for `E1.E2` given in
+[[expr.ref]].
+[*Note 1*:
+It is not possible to use a pointer to member that refers to a `mutable`
+member to modify a const class object. For example,
+``` cpp
+struct S {
+  S() : i(0) { }
+  mutable int i;
+};
+void f()
+{
+const S cs;
+int S::* pm = &S::i;            // pm refers to mutable member S::i
+cs.*pm = 88;                    // error: cs is a const object
+}
+```
+— *end note*]
+If the result of `.*` or `->*` is a function, then that result can be
+used only as the operand for the function call operator `()`.
+[*Example 1*:
+``` cpp
+(ptr_to_obj->*ptr_to_mfct)(10);
+```
+calls the member function denoted by `ptr_to_mfct` for the object
+pointed to by `ptr_to_obj`.
+— *end example*]
+In a `.*` expression whose object expression is an rvalue, the program
+is ill-formed if the second operand is a pointer to member function
+whose *ref-qualifier* is `&`, unless its *cv-qualifier-seq* is `const`.
+In a `.*` expression whose object expression is an lvalue, the program
+is ill-formed if the second operand is a pointer to member function
+whose *ref-qualifier* is `&&`. The result of a `.*` expression whose
+second operand is a pointer to a data member is an lvalue if the first
+operand is an lvalue and an xvalue otherwise. The result of a `.*`
+expression whose second operand is a pointer to a member function is a
+prvalue. If the second operand is the null member pointer value
+[[conv.mem]], the behavior is undefined.
+### Multiplicative operators <a id="expr.mul">[[expr.mul]]</a>
+The multiplicative operators `*`, `/`, and `%` group left-to-right.
+``` bnf
+multiplicative-expression:
+    pm-expression
+    multiplicative-expression '*' pm-expression
+    multiplicative-expression '/' pm-expression
+    multiplicative-expression '%' pm-expression
+```
+The operands of `*` and `/` shall have arithmetic or unscoped
+enumeration type; the operands of `%` shall have integral or unscoped
+enumeration type. The usual arithmetic conversions [[expr.arith.conv]]
+are performed on the operands and determine the type of the result.
+The binary `*` operator indicates multiplication.
+The binary `/` operator yields the quotient, and the binary `%` operator
+yields the remainder from the division of the first expression by the
+second. If the second operand of `/` or `%` is zero the behavior is
+undefined. For integral operands the `/` operator yields the algebraic
+quotient with any fractional part discarded;[^28] if the quotient `a/b`
+is representable in the type of the result, `(a/b)*b + a%b` is equal to
+`a`; otherwise, the behavior of both `a/b` and `a%b` is undefined.
+### Additive operators <a id="expr.add">[[expr.add]]</a>
+The additive operators `+` and `-` group left-to-right. The usual
+arithmetic conversions [[expr.arith.conv]] are performed for operands of
+arithmetic or enumeration type.
+``` bnf
+additive-expression:
+    multiplicative-expression
+    additive-expression '+' multiplicative-expression
+    additive-expression '-' multiplicative-expression
+```
+For addition, either both operands shall have arithmetic or unscoped
+enumeration type, or one operand shall be a pointer to a
+completely-defined object type and the other shall have integral or
+unscoped enumeration type.
+For subtraction, one of the following shall hold:
+- both operands have arithmetic or unscoped enumeration type; or
+- both operands are pointers to cv-qualified or cv-unqualified versions
+  of the same completely-defined object type; or
+- the left operand is a pointer to a completely-defined object type and
+  the right operand has integral or unscoped enumeration type.
+The result of the binary `+` operator is the sum of the operands. The
+result of the binary `-` operator is the difference resulting from the
+subtraction of the second operand from the first.
+When an expression `J` that has integral type is added to or subtracted
+from an expression `P` of pointer type, the result has the type of `P`.
+- If `P` evaluates to a null pointer value and `J` evaluates to 0, the
+  result is a null pointer value.
+- Otherwise, if `P` points to an array element i of an array object `x`
+  with n elements [[dcl.array]], [^29] the expressions `P + J` and
+  `J + P` (where `J` has the value j) point to the
+  (possibly-hypothetical) array element i + j of `x` if 0 ≤ i + j ≤ n
+  and the expression `P - J` points to the (possibly-hypothetical) array
+  element i - j of `x` if 0 ≤ i - j ≤ n.
+- Otherwise, the behavior is undefined.
+When two pointer expressions `P` and `Q` are subtracted, the type of the
+result is an *implementation-defined* signed integral type; this type
+shall be the same type that is defined as `std::ptrdiff_t` in the
+`<cstddef>` header [[support.types.layout]].
+- If `P` and `Q` both evaluate to null pointer values, the result is 0.
+- Otherwise, if `P` and `Q` point to, respectively, array elements i and
+  j of the same array object `x`, the expression `P - Q` has the value
+  i - j.
+- Otherwise, the behavior is undefined. \[*Note 1*: If the value i - j
+  is not in the range of representable values of type `std::ptrdiff_t`,
+  the behavior is undefined. — *end note*]
+For addition or subtraction, if the expressions `P` or `Q` have type
+“pointer to cv `T`”, where `T` and the array element type are not
+similar [[conv.qual]], the behavior is undefined.
+[*Note 2*: In particular, a pointer to a base class cannot be used for
+pointer arithmetic when the array contains objects of a derived class
+type. — *end note*]
+### Shift operators <a id="expr.shift">[[expr.shift]]</a>
+The shift operators `<<` and `>>` group left-to-right.
+``` bnf
+shift-expression:
+    additive-expression
+    shift-expression '<<' additive-expression
+    shift-expression '>>' additive-expression
+```
+The operands shall be of integral or unscoped enumeration type and
+integral promotions are performed. The type of the result is that of the
+promoted left operand. The behavior is undefined if the right operand is
+negative, or greater than or equal to the width of the promoted left
+operand.
+The value of `E1 << E2` is the unique value congruent to `E1` × 2^`E2`
+modulo 2ᴺ, where N is the width of the type of the result.
+[*Note 1*: `E1` is left-shifted `E2` bit positions; vacated bits are
+zero-filled. — *end note*]
+The value of `E1 >> E2` is `E1` / 2^`E2`, rounded down.
+[*Note 2*: `E1` is right-shifted `E2` bit positions. Right-shift on
+signed integral types is an arithmetic right shift, which performs
+sign-extension. — *end note*]
+The expression `E1` is sequenced before the expression `E2`.
+### Three-way comparison operator <a id="expr.spaceship">[[expr.spaceship]]</a>
+The three-way comparison operator groups left-to-right.
+``` bnf
+compare-expression:
+    shift-expression
+    compare-expression '<=>' shift-expression
+```
+The expression `p <=> q` is a prvalue indicating whether `p` is less
+than, equal to, greater than, or incomparable with `q`.
+If one of the operands is of type `bool` and the other is not, the
+program is ill-formed.
+If both operands have arithmetic types, or one operand has integral type
+and the other operand has unscoped enumeration type, the usual
+arithmetic conversions [[expr.arith.conv]] are applied to the operands.
+Then:
+- If a narrowing conversion [[dcl.init.list]] is required, other than
+  from an integral type to a floating-point type, the program is
+  ill-formed.
+- Otherwise, if the operands have integral type, the result is of type
+  `std::strong_ordering`. The result is `std::strong_ordering::equal` if
+  both operands are arithmetically equal, `std::strong_ordering::less`
+  if the first operand is arithmetically less than the second operand,
+  and `std::strong_ordering::greater` otherwise.
+- Otherwise, the operands have floating-point type, and the result is of
+  type `std::partial_ordering`. The expression `a <=> b` yields
+  `std::partial_ordering::less` if `a` is less than `b`,
+  `std::partial_ordering::greater` if `a` is greater than `b`,
+  `std::partial_ordering::equivalent` if `a` is equivalent to `b`, and
+  `std::partial_ordering::unordered` otherwise.
+If both operands have the same enumeration type `E`, the operator yields
+the result of converting the operands to the underlying type of `E` and
+applying `<=>` to the converted operands.
+If at least one of the operands is of pointer type and the other operand
+is of pointer or array type, array-to-pointer conversions
+[[conv.array]], pointer conversions [[conv.ptr]], and qualification
+conversions [[conv.qual]] are performed on both operands to bring them
+to their composite pointer type [[expr.type]]. After the conversions,
+the operands shall have the same type.
+[*Note 1*: If both of the operands are arrays, array-to-pointer
+conversions [[conv.array]] are not applied. — *end note*]
+If the composite pointer type is an object pointer type, `p <=> q` is of
+type `std::strong_ordering`. If two pointer operands `p` and `q` compare
+equal [[expr.eq]], `p <=> q` yields `std::strong_ordering::equal`; if
+`p` and `q` compare unequal, `p <=> q` yields
+`std::strong_ordering::less` if `q` compares greater than `p` and
+`std::strong_ordering::greater` if `p` compares greater than `q`
+[[expr.rel]]. Otherwise, the result is unspecified.
+Otherwise, the program is ill-formed.
+The three comparison category types [[cmp.categories]] (the types
+`std::strong_ordering`, `std::weak_ordering`, and
+`std::partial_ordering`) are not predefined; if the header `<compare>`
+is not imported or included prior to a use of such a class type – even
+an implicit use in which the type is not named (e.g., via the `auto`
+specifier [[dcl.spec.auto]] in a defaulted three-way comparison
+[[class.spaceship]] or use of the built-in operator) – the program is
+ill-formed.
+### Relational operators <a id="expr.rel">[[expr.rel]]</a>
+The relational operators group left-to-right.
+[*Example 1*: `a<b<c` means `(a<b)<c` and *not*
+`(a<b)&&(b<c)`. — *end example*]
+``` bnf
+relational-expression:
+    compare-expression
+    relational-expression '<' compare-expression
+    relational-expression '>' compare-expression
+    relational-expression '<=' compare-expression
+    relational-expression '>=' compare-expression
+```
+The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
+function-to-pointer [[conv.func]] standard conversions are performed on
+the operands. The comparison is deprecated if both operands were of
+array type prior to these conversions [[depr.array.comp]].
+The converted operands shall have arithmetic, enumeration, or pointer
+type. The operators `<` (less than), `>` (greater than), `<=` (less than
+or equal to), and `>=` (greater than or equal to) all yield `false` or
+`true`. The type of the result is `bool`.
+The usual arithmetic conversions [[expr.arith.conv]] are performed on
+operands of arithmetic or enumeration type. If both operands are
+pointers, pointer conversions [[conv.ptr]] and qualification conversions
+[[conv.qual]] are performed to bring them to their composite pointer
+type [[expr.type]]. After conversions, the operands shall have the same
+type.
+The result of comparing unequal pointers to objects [^30] is defined in
+terms of a partial order consistent with the following rules:
+- If two pointers point to different elements of the same array, or to
+  subobjects thereof, the pointer to the element with the higher
+  subscript is required to compare greater.
+- If two pointers point to different non-static data members of the same
+  object, or to subobjects of such members, recursively, the pointer to
+  the later declared member is required to compare greater provided the
+  two members have the same access control [[class.access]], neither
+  member is a subobject of zero size, and their class is not a union.
+- Otherwise, neither pointer is required to compare greater than the
+  other.
+If two operands `p` and `q` compare equal [[expr.eq]], `p<=q` and `p>=q`
+both yield `true` and `p<q` and `p>q` both yield `false`. Otherwise, if
+a pointer `p` compares greater than a pointer `q`, `p>=q`, `p>q`,
+`q<=p`, and `q<p` all yield `true` and `p<=q`, `p<q`, `q>=p`, and `q>p`
+all yield `false`. Otherwise, the result of each of the operators is
+unspecified.
+If both operands (after conversions) are of arithmetic or enumeration
+type, each of the operators shall yield `true` if the specified
+relationship is true and `false` if it is false.
+### Equality operators <a id="expr.eq">[[expr.eq]]</a>
+``` bnf
+equality-expression:
+    relational-expression
+    equality-expression '==' relational-expression
+    equality-expression '!=' relational-expression
+```
+The `==` (equal to) and the `!=` (not equal to) operators group
+left-to-right. The lvalue-to-rvalue [[conv.lval]], array-to-pointer
+[[conv.array]], and function-to-pointer [[conv.func]] standard
+conversions are performed on the operands. The comparison is deprecated
+if both operands were of array type prior to these conversions
+[[depr.array.comp]].
+The converted operands shall have arithmetic, enumeration, pointer, or
+pointer-to-member type, or type `std::nullptr_t`. The operators `==` and
+`!=` both yield `true` or `false`, i.e., a result of type `bool`. In
+each case below, the operands shall have the same type after the
+specified conversions have been applied.
+If at least one of the operands is a pointer, pointer conversions
+[[conv.ptr]], function pointer conversions [[conv.fctptr]], and
+qualification conversions [[conv.qual]] are performed on both operands
+to bring them to their composite pointer type [[expr.type]]. Comparing
+pointers is defined as follows:
+- If one pointer represents the address of a complete object, and
+  another pointer represents the address one past the last element of a
+  different complete object, [^31] the result of the comparison is
+  unspecified.
+- Otherwise, if the pointers are both null, both point to the same
+  function, or both represent the same address [[basic.compound]], they
+  compare equal.
+- Otherwise, the pointers compare unequal.
+If at least one of the operands is a pointer to member,
+pointer-to-member conversions [[conv.mem]], function pointer conversions
+[[conv.fctptr]], and qualification conversions [[conv.qual]] are
+performed on both operands to bring them to their composite pointer type
+[[expr.type]]. Comparing pointers to members is defined as follows:
+- If two pointers to members are both the null member pointer value,
+  they compare equal.
+- If only one of two pointers to members is the null member pointer
+  value, they compare unequal.
+- If either is a pointer to a virtual member function, the result is
+  unspecified.
+- If one refers to a member of class `C1` and the other refers to a
+  member of a different class `C2`, where neither is a base class of the
+  other, the result is unspecified.
+  \[*Example 1*:
+  ``` cpp
+  struct A {};
+  struct B : A { int x; };
+  struct C : A { int x; };
+  int A::*bx = (int(A::*))&B::x;
+  int A::*cx = (int(A::*))&C::x;
+  bool b1 = (bx == cx);   // unspecified
+  ```
+  — *end example*]
+- If both refer to (possibly different) members of the same union
+  [[class.union]], they compare equal.
+- Otherwise, two pointers to members compare equal if they would refer
+  to the same member of the same most derived object [[intro.object]] or
+  the same subobject if indirection with a hypothetical object of the
+  associated class type were performed, otherwise they compare unequal.
+  \[*Example 2*:
+  ``` cpp
+  struct B {
+    int f();
+  };
+  struct L : B { };
+  struct R : B { };
+  struct D : L, R { };
+  int (B::*pb)() = &B::f;
+  int (L::*pl)() = pb;
+  int (R::*pr)() = pb;
+  int (D::*pdl)() = pl;
+  int (D::*pdr)() = pr;
+  bool x = (pdl == pdr);          // false
+  bool y = (pb == pl);            // true
+  ```
+  — *end example*]
+Two operands of type `std::nullptr_t` or one operand of type
+`std::nullptr_t` and the other a null pointer constant compare equal.
+If two operands compare equal, the result is `true` for the `==`
+operator and `false` for the `!=` operator. If two operands compare
+unequal, the result is `false` for the `==` operator and `true` for the
+`!=` operator. Otherwise, the result of each of the operators is
+unspecified.
+If both operands are of arithmetic or enumeration type, the usual
+arithmetic conversions [[expr.arith.conv]] are performed on both
+operands; each of the operators shall yield `true` if the specified
+relationship is true and `false` if it is false.
+### Bitwise AND operator <a id="expr.bit.and">[[expr.bit.and]]</a>
+``` bnf
+and-expression:
+    equality-expression
+    and-expression '&' equality-expression
+```
+The `&` operator groups left-to-right. The operands shall be of integral
+or unscoped enumeration type. The usual arithmetic conversions
+[[expr.arith.conv]] are performed. Given the coefficients `xᵢ` and `yᵢ`
+of the base-2 representation [[basic.fundamental]] of the converted
+operands `x` and `y`, the coefficient `rᵢ` of the base-2 representation
+of the result `r` is 1 if both `xᵢ` and `yᵢ` are 1, and 0 otherwise.
+[*Note 1*: The result is the bitwise function of the
+operands. — *end note*]
+### Bitwise exclusive OR operator <a id="expr.xor">[[expr.xor]]</a>
+``` bnf
+exclusive-or-expression:
+    and-expression
+    exclusive-or-expression '^' and-expression
+```
+The `^` operator groups left-to-right. The operands shall be of integral
+or unscoped enumeration type. The usual arithmetic conversions
+[[expr.arith.conv]] are performed. Given the coefficients `xᵢ` and `yᵢ`
+of the base-2 representation [[basic.fundamental]] of the converted
+operands `x` and `y`, the coefficient `rᵢ` of the base-2 representation
+of the result `r` is 1 if either (but not both) of `xᵢ` and `yᵢ` are 1,
+and 0 otherwise.
+[*Note 1*: The result is the bitwise exclusive function of the
+operands. — *end note*]
+### Bitwise inclusive OR operator <a id="expr.or">[[expr.or]]</a>
+``` bnf
+inclusive-or-expression:
+    exclusive-or-expression
+    inclusive-or-expression '|' exclusive-or-expression
+```
+The `|` operator groups left-to-right. The operands shall be of integral
+or unscoped enumeration type. The usual arithmetic conversions
+[[expr.arith.conv]] are performed. Given the coefficients `xᵢ` and `yᵢ`
+of the base-2 representation [[basic.fundamental]] of the converted
+operands `x` and `y`, the coefficient `rᵢ` of the base-2 representation
+of the result `r` is 1 if at least one of `xᵢ` and `yᵢ` are 1, and 0
+otherwise.
+[*Note 1*: The result is the bitwise inclusive function of the
+operands. — *end note*]
+### Logical AND operator <a id="expr.log.and">[[expr.log.and]]</a>
+``` bnf
+logical-and-expression:
+    inclusive-or-expression
+    logical-and-expression '&&' inclusive-or-expression
+```
+The `&&` operator groups left-to-right. The operands are both
+contextually converted to `bool` [[conv]]. The result is `true` if both
+operands are `true` and `false` otherwise. Unlike `&`, `&&` guarantees
+left-to-right evaluation: the second operand is not evaluated if the
+first operand is `false`.
+The result is a `bool`. If the second expression is evaluated, the first
+expression is sequenced before the second expression
+[[intro.execution]].
+### Logical OR operator <a id="expr.log.or">[[expr.log.or]]</a>
+``` bnf
+logical-or-expression:
+    logical-and-expression
+    logical-or-expression '||' logical-and-expression
+```
+The `||` operator groups left-to-right. The operands are both
+contextually converted to `bool` [[conv]]. The result is `true` if
+either of its operands is `true`, and `false` otherwise. Unlike `|`,
+`||` guarantees left-to-right evaluation; moreover, the second operand
+is not evaluated if the first operand evaluates to `true`.
+The result is a `bool`. If the second expression is evaluated, the first
+expression is sequenced before the second expression
+[[intro.execution]].
+### Conditional operator <a id="expr.cond">[[expr.cond]]</a>
+``` bnf
+conditional-expression:
+    logical-or-expression
+    logical-or-expression '?' expression ':' assignment-expression
+```
+Conditional expressions group right-to-left. The first expression is
+contextually converted to `bool` [[conv]]. It is evaluated and if it is
+`true`, the result of the conditional expression is the value of the
+second expression, otherwise that of the third expression. Only one of
+the second and third expressions is evaluated. The first expression is
+sequenced before the second or third expression [[intro.execution]].
+If either the second or the third operand has type `void`, one of the
+following shall hold:
+- The second or the third operand (but not both) is a (possibly
+  parenthesized) *throw-expression* [[expr.throw]]; the result is of the
+  type and value category of the other. The *conditional-expression* is
+  a bit-field if that operand is a bit-field.
+- Both the second and the third operands have type `void`; the result is
+  of type `void` and is a prvalue. \[*Note 1*: This includes the case
+  where both operands are *throw-expression*s. — *end note*]
+Otherwise, if the second and third operand are glvalue bit-fields of the
+same value category and of types *cv1* `T` and *cv2* `T`, respectively,
+the operands are considered to be of type cv `T` for the remainder of
+this subclause, where cv is the union of *cv1* and *cv2*.
+Otherwise, if the second and third operand have different types and
+either has (possibly cv-qualified) class type, or if both are glvalues
+of the same value category and the same type except for
+cv-qualification, an attempt is made to form an implicit conversion
+sequence [[over.best.ics]] from each of those operands to the type of
+the other.
+[*Note 2*: Properties such as access, whether an operand is a
+bit-field, or whether a conversion function is deleted are ignored for
+that determination. — *end note*]
+Attempts are made to form an implicit conversion sequence from an
+operand expression `E1` of type `T1` to a target type related to the
+type `T2` of the operand expression `E2` as follows:
+- If `E2` is an lvalue, the target type is “lvalue reference to `T2`”,
+  subject to the constraint that in the conversion the reference must
+  bind directly [[dcl.init.ref]] to a glvalue.
+- If `E2` is an xvalue, the target type is “rvalue reference to `T2`”,
+  subject to the constraint that the reference must bind directly.
+- If `E2` is a prvalue or if neither of the conversion sequences above
+  can be formed and at least one of the operands has (possibly
+  cv-qualified) class type:
+  - if `T1` and `T2` are the same class type (ignoring cv-qualification)
+    and `T2` is at least as cv-qualified as `T1`, the target type is
+    `T2`,
+  - otherwise, if `T2` is a base class of `T1`, the target type is *cv1*
+    `T2`, where *cv1* denotes the cv-qualifiers of `T1`,
+  - otherwise, the target type is the type that `E2` would have after
+    applying the lvalue-to-rvalue [[conv.lval]], array-to-pointer
+    [[conv.array]], and function-to-pointer [[conv.func]] standard
+    conversions.
+Using this process, it is determined whether an implicit conversion
+sequence can be formed from the second operand to the target type
+determined for the third operand, and vice versa. If both sequences can
+be formed, or one can be formed but it is the ambiguous conversion
+sequence, the program is ill-formed. If no conversion sequence can be
+formed, the operands are left unchanged and further checking is
+performed as described below. Otherwise, if exactly one conversion
+sequence can be formed, that conversion is applied to the chosen operand
+and the converted operand is used in place of the original operand for
+the remainder of this subclause.
+[*Note 3*: The conversion might be ill-formed even if an implicit
+conversion sequence could be formed. — *end note*]
+If the second and third operands are glvalues of the same value category
+and have the same type, the result is of that type and value category
+and it is a bit-field if the second or the third operand is a bit-field,
+or if both are bit-fields.
+Otherwise, the result is a prvalue. If the second and third operands do
+not have the same type, and either has (possibly cv-qualified) class
+type, overload resolution is used to determine the conversions (if any)
+to be applied to the operands ([[over.match.oper]], [[over.built]]). If
+the overload resolution fails, the program is ill-formed. Otherwise, the
+conversions thus determined are applied, and the converted operands are
+used in place of the original operands for the remainder of this
+subclause.
+Lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
+function-to-pointer [[conv.func]] standard conversions are performed on
+the second and third operands. After those conversions, one of the
+following shall hold:
+- The second and third operands have the same type; the result is of
+  that type and the result object is initialized using the selected
+  operand.
+- The second and third operands have arithmetic or enumeration type; the
+  usual arithmetic conversions [[expr.arith.conv]] are performed to
+  bring them to a common type, and the result is of that type.
+- One or both of the second and third operands have pointer type;
+  pointer conversions [[conv.ptr]], function pointer conversions
+  [[conv.fctptr]], and qualification conversions [[conv.qual]] are
+  performed to bring them to their composite pointer type [[expr.type]].
+  The result is of the composite pointer type.
+- One or both of the second and third operands have pointer-to-member
+  type; pointer to member conversions [[conv.mem]], function pointer
+  conversions [[conv.fctptr]], and qualification conversions
+  [[conv.qual]] are performed to bring them to their composite pointer
+  type [[expr.type]]. The result is of the composite pointer type.
+- Both the second and third operands have type `std::nullptr_t` or one
+  has that type and the other is a null pointer constant. The result is
+  of type `std::nullptr_t`.
+### Yielding a value <a id="expr.yield">[[expr.yield]]</a>
+``` bnf
+yield-expression:
+  'co_yield' assignment-expression
+  'co_yield' braced-init-list
+```
+A *yield-expression* shall appear only within a suspension context of a
+function [[expr.await]]. Let *e* be the operand of the
+*yield-expression* and *p* be an lvalue naming the promise object of the
+enclosing coroutine [[dcl.fct.def.coroutine]], then the
+*yield-expression* is equivalent to the expression
+`co_await `*p*`.yield_value(`*e*`)`.
+[*Example 1*:
+``` cpp
+template <typename T>
+struct my_generator {
+  struct promise_type {
+    T current_value;
+    ...
+    auto yield_value(T v) {
+      current_value = std::move(v);
+      return std::suspend_always{};
+    }
+  };
+  struct iterator { ... };
+  iterator begin();
+  iterator end();
+};
+my_generator<pair<int,int>> g1() {
+  for (int i = i; i < 10; ++i) co_yield {i,i};
+}
+my_generator<pair<int,int>> g2() {
+  for (int i = i; i < 10; ++i) co_yield make_pair(i,i);
+}
+auto f(int x = co_yield 5);     // error: yield-expression outside of function suspension context
+int a[] = { co_yield 1 };       // error: yield-expression outside of function suspension context
+int main() {
+  auto r1 = g1();
+  auto r2 = g2();
+  assert(std::equal(r1.begin(), r1.end(), r2.begin(), r2.end()));
+}
+```
+— *end example*]
+### Throwing an exception <a id="expr.throw">[[expr.throw]]</a>
+``` bnf
+throw-expression:
+    throw assignment-expressionₒₚₜ
+```
+A *throw-expression* is of type `void`.
+Evaluating a *throw-expression* with an operand throws an exception
+[[except.throw]]; the type of the exception object is determined by
+removing any top-level *cv-qualifier*s from the static type of the
+operand and adjusting the type from “array of `T`” or function type `T`
+to “pointer to `T`”.
+A *throw-expression* with no operand rethrows the currently handled
+exception [[except.handle]]. The exception is reactivated with the
+existing exception object; no new exception object is created. The
+exception is no longer considered to be caught.
+[*Example 1*:
+Code that must be executed because of an exception, but cannot
+completely handle the exception itself, can be written like this:
+``` cpp
+try {
+  // ...
+} catch (...) {     // catch all exceptions
+  // respond (partially) to exception
+  throw;            // pass the exception to some other handler
+}
+```
+— *end example*]
+If no exception is presently being handled, evaluating a
+*throw-expression* with no operand calls `std::{}terminate()`
+[[except.terminate]].
+### Assignment and compound assignment operators <a id="expr.ass">[[expr.ass]]</a>
+The assignment operator (`=`) and the compound assignment operators all
+group right-to-left. All require a modifiable lvalue as their left
+operand; their result is an lvalue referring to the left operand. The
+result in all cases is a bit-field if the left operand is a bit-field.
+In all cases, the assignment is sequenced after the value computation of
+the right and left operands, and before the value computation of the
+assignment expression. The right operand is sequenced before the left
+operand. With respect to an indeterminately-sequenced function call, the
+operation of a compound assignment is a single evaluation.
+[*Note 1*: Therefore, a function call cannot intervene between the
+lvalue-to-rvalue conversion and the side effect associated with any
+single compound assignment operator. — *end note*]
+``` bnf
+assignment-expression:
+    conditional-expression
+    yield-expression
+    throw-expression
+    logical-or-expression assignment-operator initializer-clause
+```
+``` bnf
+assignment-operator: one of
+    '= *= /= %= += -= >>= <<= &= ^= |='
+```
+In simple assignment (`=`), the object referred to by the left operand
+is modified [[defns.access]] by replacing its value with the result of
+the right operand.
+If the right operand is an expression, it is implicitly converted
+[[conv]] to the cv-unqualified type of the left operand.
+When the left operand of an assignment operator is a bit-field that
+cannot represent the value of the expression, the resulting value of the
+bit-field is *implementation-defined*.
+A simple assignment whose left operand is of a volatile-qualified type
+is deprecated [[depr.volatile.type]] unless the (possibly parenthesized)
+assignment is a discarded-value expression or an unevaluated operand.
+The behavior of an expression of the form `E1 op= E2` is equivalent to
+`E1 = E1 op E2` except that `E1` is evaluated only once. Such
+expressions are deprecated if `E1` has volatile-qualified type; see
+[[depr.volatile.type]]. For `+=` and `-=`, `E1` shall either have
+arithmetic type or be a pointer to a possibly cv-qualified
+completely-defined object type. In all other cases, `E1` shall have
+arithmetic type.
+If the value being stored in an object is read via another object that
+overlaps in any way the storage of the first object, then the overlap
+shall be exact and the two objects shall have the same type, otherwise
+the behavior is undefined.
+[*Note 2*: This restriction applies to the relationship between the
+left and right sides of the assignment operation; it is not a statement
+about how the target of the assignment may be aliased in general. See
+[[basic.lval]]. — *end note*]
+A *braced-init-list* may appear on the right-hand side of
+- an assignment to a scalar, in which case the initializer list shall
+  have at most a single element. The meaning of `x = {v}`, where `T` is
+  the scalar type of the expression `x`, is that of `x = T{v}`. The
+  meaning of `x = {}` is `x = T{}`.
+- an assignment to an object of class type, in which case the
+  initializer list is passed as the argument to the assignment operator
+  function selected by overload resolution ([[over.ass]],
+  [[over.match]]).
+[*Example 1*:
+``` cpp
+complex<double> z;
+z = { 1,2 };        // meaning z.operator=({1,2\)}
+z += { 1, 2 };      // meaning z.operator+=({1,2\)}
+int a, b;
+a = b = { 1 };      // meaning a=b=1;
+a = { 1 } = b;      // syntax error
+```
+— *end example*]
+### Comma operator <a id="expr.comma">[[expr.comma]]</a>
+The comma operator groups left-to-right.
+``` bnf
+expression:
+    assignment-expression
+    expression ',' assignment-expression
+```
+A pair of expressions separated by a comma is evaluated left-to-right;
+the left expression is a discarded-value expression [[expr.prop]]. The
+left expression is sequenced before the right expression
+[[intro.execution]]. The type and value of the result are the type and
+value of the right operand; the result is of the same value category as
+its right operand, and is a bit-field if its right operand is a
+bit-field.
+In contexts where comma is given a special meaning,
+[*Example 1*: in lists of arguments to functions [[expr.call]] and
+lists of initializers [[dcl.init]] — *end example*]
+the comma operator as described in this subclause can appear only in
+parentheses.
+[*Example 2*:
+``` cpp
+f(a, (t=3, t+2), c);
+```
+has three arguments, the second of which has the value `5`.
+— *end example*]
+[*Note 1*: A comma expression appearing as the
+*expr-or-braced-init-list* of a subscripting expression [[expr.sub]] is
+deprecated; see [[depr.comma.subscript]]. — *end note*]

Diff to HTML by rtfpessoa