[expr.unary] - C++14 → C++17

Files changed (1) hide show

tmp/tmpmztxuygi/{from.md → to.md} +346 -219

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

@@ -26,61 +26,79 @@ unary-operator: one of
 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`.” 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]].
 The result of each of the following unary operators is a prvalue.
 The result of the unary `&` operator is a pointer to its operand. The
 operand shall be an lvalue or a *qualified-id*. If the operand is a
-*qualified-id* naming a non-static 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 type of the
-expression is `T`, the result has type “pointer to `T`” and is a prvalue
-that is the address of the designated object ([[intro.memory]]) or a
-pointer to the designated function. In particular, the address of an
-object of type “cv `T`” is “pointer to cv `T`”, with the same
-cv-qualification.
 ``` cpp
 struct A { int i; };
 struct B : A { };
 ... &B::i ...       // has type int A::*
 ```
-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.
 A pointer to member is only formed when an explicit `&` is used and its
-operand is a *qualified-id* not enclosed in parentheses. 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.
 If `&` is applied to an lvalue of incomplete class type and the complete
 type declares `operator&()`, it is unspecified whether the operator has
 the built-in meaning or the operator function is called. The operand of
 `&` shall not be a bit-field.
 The address of an overloaded function (Clause  [[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.”
 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.
@@ -96,51 +114,61 @@ The operand of the logical negation operator `!` is contextually
 converted to `bool` (Clause  [[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 one’s 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 *unary-expression* `~X()`, where `X` is a
-*class-name* or *decltype-specifier*. The ambiguity is resolved in favor
-of treating `~` as a unary complement rather than treating `~X` as
-referring to a destructor.
 ### Increment and decrement <a id="expr.pre.incr">[[expr.pre.incr]]</a>
-The operand of prefix `++` is modified by adding `1`, or set to `true`
-if it is `bool` (this use is deprecated). The operand shall be a
-modifiable lvalue. The type of the operand shall be an arithmetic type
-or a pointer to a completely-defined object type. The result is the
-updated operand; it is an lvalue, and it is a bit-field if the operand
-is a bit-field. If `x` is not of type `bool`, the expression `++x` is
-equivalent to `x+=1` See the discussions of addition ([[expr.add]]) and
-assignment operators ([[expr.ass]]) for information on conversions.
-The operand of prefix `\dcr` is modified by subtracting `1`. The operand
-shall not be of type `bool`. The requirements on the operand of prefix
-`\dcr` and the properties of its result are otherwise the same as those
-of prefix `++`. For postfix increment and decrement, see
-[[expr.post.incr]].
 ### Sizeof <a id="expr.sizeof">[[expr.sizeof]]</a>
 The `sizeof` operator yields the number of bytes in the object
 representation of its operand. The operand is either an expression,
 which is an unevaluated operand (Clause  [[expr]]), or a parenthesized
 *type-id*. The `sizeof` operator shall not be applied to an expression
-that has function or incomplete type, to an enumeration type whose
-underlying type is not fixed before all its enumerators have been
-declared, to the parenthesized name of such types, or to a glvalue that
-designates a bit-field. `sizeof(char)`, `sizeof(signed char)` and
-`sizeof(unsigned char)` are `1`. The result of `sizeof` applied to any
-other fundamental type ([[basic.fundamental]]) is
-*implementation-defined*. in particular, `sizeof(bool)`,
-`sizeof(char16_t)`, `sizeof(char32_t)`, and `sizeof(wchar_t)` are
-implementation-defined.[^16] See  [[intro.memory]] for the definition of
-*byte* and  [[basic.types]] for the definition of *object
-representation*.
 When applied to a reference or 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 size of a
@@ -153,40 +181,50 @@ number of bytes in the array. This implies that the size of an array of
 The `sizeof` operator can be applied to a pointer to a function, but
 shall not be applied directly to a function.
 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`.
 The identifier in a `sizeof...` expression shall name a parameter pack.
 The `sizeof...` operator yields the number of arguments provided for the
 parameter pack *identifier*. A `sizeof...` expression is a pack
 expansion ([[temp.variadic]]).
 ``` cpp
 template<class... Types>
 struct count {
   static const std::size_t value = sizeof...(Types);
 };
 ```
 The result of `sizeof` and `sizeof...` is a constant of type
-`std::size_t`. `std::size_t` is defined in the standard header
-`<cstddef>` ([[support.types]]).
 ### 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]]). It is
-*implementation-defined* whether over-aligned types are supported (
-[[basic.align]]). because references are not objects, references cannot
-be created by *new-expression*s. the *type-id* may be a cv-qualified
-type, in which case the object created by the *new-expression* has a
-cv-qualified type.
 ``` bnf
 new-expression:
     '::'ₒₚₜ 'new' new-placementₒₚₜ new-type-id new-initializerₒₚₜ
     '::'ₒₚₜ 'new' new-placementₒₚₜ '(' type-id ')' new-initializerₒₚₜ
@@ -219,50 +257,67 @@ new-initializer:
     '(' expression-listₒₚₜ ')'
     braced-init-list
 ```
 Entities created by a *new-expression* have dynamic storage duration (
-[[basic.stc.dynamic]]). the lifetime of such an entity is not
-necessarily restricted to the scope in which it is created. If the
-entity is a non-array object, the *new-expression* returns a pointer to
-the object created. If it is an array, the *new-expression* returns a
-pointer to the initial element of the array.
-If the `auto` appears in the of a or of a , the shall contain a of the
-form
-``` bnf
-'(' assignment-expression ')'
-```
-The allocated type is deduced from the as follows: Let `e` be the
-*assignment-expression* in the and `T` be the or of the , then the
-allocated type is the type deduced for the variable `x` in the invented
-declaration ([[dcl.spec.auto]]):
 ``` cpp
-T x(e);
 ```
 ``` cpp
 new auto(1);                    // allocated type is int
 auto x = new auto('a');         // allocated type is char, x is of type char*
 ```
 The *new-type-id* in a *new-expression* is the longest possible sequence
-of *new-declarator*s. this prevents ambiguities between the declarator
-operators `&`, `&&`, `*`, and `[]` and their expression counterparts.
 ``` 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.
-parentheses in a *new-type-id* of a *new-expression* can have surprising
 effects.
 ``` cpp
 new int(*[10])();               // error
 ```
 is ill-formed because the binding is
@@ -277,66 +332,85 @@ 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`.
 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. both `new int` and `new int[10]`
-have type `int*` and the type of `new int[i][10]` is `int (*)[10]` 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 shall evaluate to a strictly positive value. The *expression* in a
-*noptr-new-declarator*is implicitly converted to `std::size_t`. 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).
 The *expression* in a *noptr-new-declarator* 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]])[^18] is less than
   zero;
 - its value is such that the size of the allocated object would exceed
-  the implementation-defined limit (annex  [[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*, after converting to `std::size_t`, is a core
-constant expression and the expression is erroneous, the program is
-ill-formed. Otherwise, a *new-expression* with an erroneous expression
-does not call an allocation function and 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[]`. an
-implementation shall 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]]).
 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
@@ -362,10 +436,12 @@ true were the allocation not extended:
   *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`.
 ``` cpp
   void mergeable(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]};
@@ -384,110 +460,140 @@ void mergeable(int x) {
       throw;
     }
   }
 ```
 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. For arrays of `char` and
-`unsigned char`, 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. 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.
 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. If used, overload resolution is performed on a
-function call created by assembling an argument list consisting of the
-amount of space requested (the first argument) and the expressions in
-the *new-placement* part of the *new-expression* (the second and
-succeeding arguments). The first of these arguments has type
-`std::size_t` and the remaining arguments have the corresponding types
-of the expressions in the *new-placement*.
-- `new T` results in a call of `operator
-  new(sizeof(T))`,
-- `new(2,f) T` results in a call of `operator
-  new(sizeof(T),2,f)`,
-- `new T[5]` results in a call of `operator
-  new[](sizeof(T)*5+x)`, and
-- `new(2,f) T[5]` results in a call of `operator
-  new[](sizeof(T)*5+y,2,f)`.
-Here, `x` and `y` are non-negative unspecified values 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 the library function `operator new[](std::size_t, void*)`
-and other placement allocation functions. The amount of overhead may
-vary from one invocation of `new` to another.
-unless an allocation function is declared with a non-throwing
-*exception-specification* ([[except.spec]]), it indicates failure to
-allocate storage by throwing a `std::bad_alloc` exception (Clause
-[[except]],  [[bad.alloc]]); it returns a non-null pointer otherwise. If
-the allocation function is declared with a non-throwing
-*exception-specification*, it returns null to indicate failure to
-allocate storage and a non-null pointer 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.
-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.
 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]]). If no initialization is
-  performed, the object has an indeterminate value.
 - Otherwise, the *new-initializer* is interpreted according to the
   initialization rules of  [[dcl.init]] for direct-initialization.
-The invocation of the allocation function is indeterminately sequenced
-with respect to the evaluations of expressions in the *new-initializer*.
-Initialization of the allocated object is sequenced before the value
-computation of the *new-expression*. It is unspecified whether
-expressions in the *new-initializer* are evaluated if the allocation
-function returns the null pointer or exits using an exception.
 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]]). 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[^19] terminates
-by throwing an exception, storage has been obtained for the object, 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. This is appropriate when the called allocation function
 does not allocate memory; otherwise, it is likely to result in a memory
-leak.
 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
@@ -499,17 +605,19 @@ 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
-the two-parameter form of a usual deallocation function (
 [[basic.stc.dynamic.deallocation]]) 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]])
 ``` cpp
 struct S {
   // Placement allocation function:
   static void* operator new(std::size_t, std::size_t);
@@ -519,10 +627,12 @@ struct S {
 S* p = new (0) S;   // ill-formed: non-placement deallocation function matches
                     // placement allocation function
 ```
 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
@@ -561,16 +671,20 @@ 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 (Clause  [[class.derived]]). If not, the behavior is
 undefined. In the second alternative (*delete array*), 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*.[^22] If not, the
-behavior is undefined. 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*. 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*.
 In the first alternative (*delete object*), if the static type of the
 object to be deleted is different from its dynamic type, 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
@@ -607,43 +721,70 @@ pointer value, then:
   *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* ([[basic.stc.dynamic.deallocation]]).
-Otherwise, it is unspecified whether the deallocation function will be
-called. The deallocation function is called regardless of whether the
-destructor for the object or some element of the array throws an
-exception.
-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]]).
 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 the type is complete and if deallocation function lookup finds both a
-usual deallocation function with only a pointer parameter and a usual
-deallocation function with both a pointer parameter and a size
-parameter, then the selected deallocation function shall be the one with
-two parameters. Otherwise, the selected deallocation function shall be
-the function with one parameter.
 When a *delete-expression* is executed, the selected deallocation
-function shall be called with the address of the block of storage to be
-reclaimed as its first argument and (if the two-parameter deallocation
-function is used) the size of the block as its second argument.[^23]
 Access and ambiguity control are done for both the deallocation function
 and the destructor ([[class.dtor]],  [[class.free]]).
 ### Alignof <a id="expr.alignof">[[expr.alignof]]</a>
@@ -670,22 +811,8 @@ noexcept-expression:
 ```
 The result of the `noexcept` operator is a constant of type `bool` and
 is a prvalue.
-The result of the `noexcept` operator is `false` if in a
-potentially-evaluated context the *expression* would contain
-- a potentially-evaluated call[^24] to a function, member function,
-  function pointer, or member function pointer that does not have a
-  non-throwing *exception-specification* ([[except.spec]]), unless the
-  call is a constant expression ([[expr.const]]),
-- a potentially-evaluated *throw-expression* ([[except.throw]]),
-- a potentially-evaluated `dynamic_cast` expression
-  `dynamic_cast<T>(v)`, where `T` is a reference type, that requires a
-  run-time check ([[expr.dynamic.cast]]), or
-- a potentially-evaluated `typeid` expression ([[expr.typeid]]) applied
-  to a glvalue expression whose type is a polymorphic class type (
-  [[class.virtual]]).
-Otherwise, the result is `true`.

 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. The
 operand shall be an lvalue or a *qualified-id*. 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 type
+of the expression is `T`, the result has type “pointer to `T`” and is a
+prvalue that is the address of the designated object ([[intro.memory]])
+or a pointer to the designated function.
+[*Note 2*: In particular, the address of an object of type “cv `T`” is
+“pointer to cv `T`”, with the same cv-qualification. — *end note*]
+For purposes of pointer arithmetic ([[expr.add]]) and comparison (
+[[expr.rel]], [[expr.eq]]), an object that is not an array element whose
+address is taken in this way is considered to belong to an array with
+one element of type `T`.
+[*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.
 The address of an overloaded function (Clause  [[over]]) can be taken
 only in a context that uniquely determines which version of the
+overloaded function is referred to (see  [[over.over]]).
+[*Note 5*: 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.
 converted to `bool` (Clause  [[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
+*class-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 *class-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 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. 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 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*]
 ### Sizeof <a id="expr.sizeof">[[expr.sizeof]]</a>
 The `sizeof` operator yields the number of bytes in the object
 representation of its operand. The operand is either an expression,
 which is an unevaluated operand (Clause  [[expr]]), 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. `sizeof(char)`,
+`sizeof(signed char)` and `sizeof(unsigned char)` are `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.[^16] — *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 or 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 size of a
 The `sizeof` operator can be applied to a pointer to a function, but
 shall not be applied directly to a function.
 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 parameter pack.
 The `sizeof...` operator yields the number of arguments provided for the
 parameter pack *identifier*. 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 constant of type
+`std::size_t`.
+[*Note 3*:  `std::size_t` is defined in the standard header
+`<cstddef>` ([[cstddef.syn]], [[support.types.layout]]). — *end note*]
 ### 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ₒₚₜ
     '(' expression-listₒₚₜ ')'
     braced-init-list
 ```
 Entities created by a *new-expression* have dynamic storage duration (
+[[basic.stc.dynamic]]).
+[*Note 3*:  The lifetime of such an entity is not necessarily
+restricted to the scope in which it is created. — *end note*]
+If the entity is a non-array object, the *new-expression* returns a
+pointer to the object created. If it is an array, the *new-expression*
+returns a pointer to the initial element of the array.
+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 4*: 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 5*:
+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])());
 ```
 allocates an array of `10` pointers to functions (taking no argument and
+returning `int`).
+— *end example*]
+— *end note*]
 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 shall evaluate to a strictly positive value. The *expression* in a
+*noptr-new-declarator* is implicitly converted to `std::size_t`.
+[*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*]
 The *expression* in a *noptr-new-declarator* 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]])[^18] is less than
   zero;
 - its value is such that the size of the allocated object would exceed
+  the *implementation-defined* limit (Annex  [[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 shall 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
   *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 mergeable(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]};
       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. 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 8*:  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 and the
+allocated object type has new-extended alignment, the alignment argument
+is removed from the argument list, and 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 the library function
+`operator new[](std::size_t, void*)` and other placement allocation
+functions. The amount of overhead may vary from one invocation of `new`
+to another.
+— *end example*]
+[*Note 9*: 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]], Clause  [[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 10*: 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 11*: 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]]). 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[^19] 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 12*: 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
 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 with a parameter of type `std::size_t` (
 [[basic.stc.dynamic.deallocation]]) 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);
 S* p = new (0) S;   // ill-formed: 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
 a pointer to a subobject ([[intro.object]]) representing a base class
 of such an object (Clause  [[class.derived]]). If not, the behavior is
 undefined. In the second alternative (*delete array*), 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*.[^22] 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 the first alternative (*delete object*), if the static type of the
 object to be deleted is different from its dynamic type, 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
   *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 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 exactly one preferred function is
+  found, that function is selected and the selection process terminates.
+  If more than one preferred function is found, all non-preferred
+  functions are eliminated from further consideration.
+- 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 the second alternative (delete
+  array) 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.
 When a *delete-expression* is executed, the selected deallocation
+function shall be called with the address of the most-derived object in
+the *delete object* case, or the address of the object suitably adjusted
+for the array allocation overhead ([[expr.new]]) in the *delete array*
+case, as its first argument. If a deallocation function with a parameter
+of type `std::align_val_t` is used, the alignment of the type of the
+object to be deleted is passed as the corresponding argument. If a
+deallocation function with a parameter of type `std::size_t` is used,
+the size of the most-derived type, or of the array plus allocation
+overhead, respectively, is passed as the corresponding argument. [^23]
+[*Note 5*: If this results in a call to a usual deallocation function,
+and either the first argument was not the result of a prior call to a
+usual allocation function or the second 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]]).
 ### Alignof <a id="expr.alignof">[[expr.alignof]]</a>
 ```
 The result of the `noexcept` operator is a constant of type `bool` and
 is a prvalue.
+The result of the `noexcept` operator is `true` unless the *expression*
+is potentially-throwing ([[except.spec]]).

Diff to HTML by rtfpessoa