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

Files changed (1) hide show

tmp/tmpejmkgq0n/{from.md → to.md} +184 -89

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

@@ -26,15 +26,15 @@ 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`.” a pointer to an
-incomplete type (other than *cv* `void`) can be dereferenced. 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
@@ -66,14 +66,14 @@ 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.
-The address of an object of incomplete type can be taken, but if the
-complete type of that object is a class type that declares `operator&()`
-as a member function, then the behavior is undefined (and no diagnostic
-is required). 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
@@ -128,27 +128,27 @@ 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 an lvalue 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.[^17] 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
 most derived class shall be greater than zero ([[intro.object]]). The
 result of applying `sizeof` to a base class subobject is the size of the
-base class type.[^18] 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 `sizeof` operator can be applied to a pointer to a function, but
 shall not be applied directly to a function.
@@ -287,35 +287,43 @@ 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 an
-integral constant expression ([[expr.const]]) and evaluate to a
-strictly positive value. The *expression* in a *noptr-new-declarator*
-shall be of integral type, unscoped enumeration type, or a class type
-for which a single non-explicit conversion function to integral or
-unscoped enumeration type exists ([[class.conv]]). If the expression is
-of class type, the expression is converted by calling that conversion
-function, and the result of the conversion is used in place of the
-original expression. 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).
-When the value of the *expression* in a *noptr-new-declarator* is zero,
-the allocation function is called to allocate an array with no elements.
-If the value of that *expression* is less than zero or such that the
-size of the allocated object would exceed the implementation-defined
-limit, or if the *new-initializer* is a *braced-init-list* for which the
-number of *initializer-clause*s exceeds the number of elements to
-initialize, no storage is obtained and 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]]).
-A *new-expression* obtains 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
@@ -333,24 +341,76 @@ 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.
-A *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.
 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
@@ -395,12 +455,12 @@ 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 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*.
@@ -410,23 +470,24 @@ 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, access and ambiguity control are done for the
-destructor ([[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. 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
@@ -435,19 +496,19 @@ 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. Any non-placement
-deallocation function matches a non-placement allocation function. 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.
 ``` cpp
 struct S {
   // Placement allocation function:
   static void* operator new(std::size_t, std::size_t);
@@ -484,13 +545,14 @@ delete-expression:
 ```
 The first alternative is for non-array objects, and the second is for
 arrays. Whenever the `delete` keyword is immediately followed by empty
 square brackets, it shall be interpreted as the second alternative.[^20]
-The operand shall have a pointer to object type, or a class type having
-a single non-explicit conversion function ([[class.conv.fct]]) to a
-pointer to object type. The result has type `void`.[^21]
 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 section. In the first alternative (*delete object*),
@@ -529,41 +591,74 @@ 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, the *delete-expression* will 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 global deallocation function is used to
-deallocate the storage.
 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>
 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 a complete object type.
 The result is an integral constant of type `std::size_t`.
-When `alignof` is applied to a reference type, the result shall be the
 alignment of the referenced type. When `alignof` is applied to an array
-type, the result shall be 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 (Clause  [[expr]]), can throw
@@ -573,24 +668,24 @@ an exception ([[except.throw]]).
 noexcept-expression:
   'noexcept' '(' expression ')'
 ```
 The result of the `noexcept` operator is a constant of type `bool` and
-is an rvalue.
 The result of the `noexcept` operator is `false` if in a
 potentially-evaluated context the *expression* would contain
-- a potentially evaluated call[^23] 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`.” 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
 “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
 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
 most derived class shall be greater than zero ([[intro.object]]). The
 result of applying `sizeof` to a base class subobject is the size of the
+base class type.[^17] 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 `sizeof` operator can be applied to a pointer to a function, but
 shall not be applied directly to a function.
 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
 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*. 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`.
+``` 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]};
+    std::unique_ptr<char[]> c{new (std::nothrow) char[x]};
+    g(a.get(), b.get(), c.get());
+  }
+  void unmergeable(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;
+    }
+  }
+```
+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
 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*.
 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
 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
+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);
 ```
 The first alternative is for non-array objects, and the second is for
 arrays. Whenever the `delete` keyword is immediately followed by empty
 square brackets, it shall be interpreted as the second alternative.[^20]
+The operand shall be of pointer to object type or of class type. If of
+class type, the operand is contextually implicitly converted (Clause
+[[conv]]) to a pointer to object type.[^21] 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 section. In the first alternative (*delete object*),
 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* ([[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>
 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 an integral constant of type `std::size_t`.
+When `alignof` is applied to a reference type, the result is the
 alignment of the referenced type. When `alignof` is applied to an array
+type, the result is the alignment of the element type.
 ### `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 (Clause  [[expr]]), can throw
 noexcept-expression:
   '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`.

Diff to HTML by rtfpessoa