[new.delete] - C++14 → C++17

Files changed (1) hide show

tmp/tmpnxmcgv06/{from.md → to.md} +205 -164

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

@@ -1,35 +1,43 @@
 ### Storage allocation and deallocation <a id="new.delete">[[new.delete]]</a>
-Except where otherwise specified, the provisions of (
-[[basic.stc.dynamic]]) apply to the library versions of `operator new`
 and `operator
-delete`.
 #### Single-object forms <a id="new.delete.single">[[new.delete.single]]</a>
 ``` cpp
 void* operator new(std::size_t size);
 ```
-*Effects:* The *allocation function* ([[basic.stc.dynamic.allocation]])
 called by a *new-expression* ([[expr.new]]) to allocate `size` bytes of
-storage suitably aligned to represent any object of that size.
-*Replaceable:* a C++program may define a function with this function
-signature that displaces the default version defined by the C++standard
-library.
 *Required behavior:* Return a non-null pointer to suitably aligned
 storage ([[basic.stc.dynamic]]), or else throw a `bad_alloc` exception.
-This requirement is binding on a replacement version of this function.
 *Default behavior:*
 - Executes a loop: Within the loop, the function first attempts to
   allocate the requested storage. Whether the attempt involves a call to
-  the Standard C library function `malloc` is unspecified.
 - Returns a pointer to the allocated storage if the attempt is
   successful. Otherwise, if the current
   `new_handler` ([[get.new.handler]]) is a null pointer value, throws
   `bad_alloc`.
 - Otherwise, the function calls the current `new_handler`
@@ -38,277 +46,308 @@ This requirement is binding on a replacement version of this function.
 - The loop terminates when an attempt to allocate the requested storage
   is successful or when a called `new_handler` function does not return.
 ``` cpp
 void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
 ```
-*Effects:* Same as above, except that it is called by a placement
 version of a *new-expression* when a C++program prefers a null pointer
 result as an error indication, instead of a `bad_alloc` exception.
-*Replaceable:* a C++program may define a function with this function
-signature that displaces the default version defined by the C++standard
-library.
 *Required behavior:* Return a non-null pointer to suitably aligned
-storage ([[basic.stc.dynamic]]), or else return a null pointer. This
-nothrow version of `operator new` returns a pointer obtained as if
-acquired from the (possibly replaced) ordinary version. This requirement
-is binding on a replacement version of this function.
-*Default behavior:* Calls `operator new(size)`. If the call returns
 normally, returns the result of that call. Otherwise, returns a null
 pointer.
 ``` cpp
 T* p1 = new T;                  // throws bad_alloc if it fails
 T* p2 = new(nothrow) T;         // returns nullptr if it fails
 ```
 ``` cpp
 void operator delete(void* ptr) noexcept;
 void operator delete(void* ptr, std::size_t size) noexcept;
 ```
-*Effects:* The *deallocation
-function* ([[basic.stc.dynamic.deallocation]]) called by a
 *delete-expression* to render the value of `ptr` invalid.
-*Replaceable:* a C++program may define a function with signature
-`void operator delete(void* ptr) noexcept` that displaces the default
-version defined by the C++standard library. If this function (without
-`size` parameter) is defined, the program should also define
-`void operator delete(void* ptr, std::size_t size) noexcept`. If this
-function with `size` parameter is defined, the program shall also define
-the version without the `size` parameter. The default behavior below may
-change in the future, which will require replacing both deallocation
-functions when replacing the allocation function.
-*Requires:* *ptr* shall be a null pointer or its value shall be a value
-returned by an earlier call to the (possibly replaced)
-`operator new(std::size_t)` or
-`operator new(std::size_t,const std::nothrow_t&)` which has not been
-invalidated by an intervening call to `operator delete(void*)`.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
-*Requires:* If present, the `std::size_t size` argument shall equal the
-size argument passed to the allocation function that returned `ptr`.
-*Required behavior:* Calls to
-`operator delete(void* ptr, std::size_t size)` may be changed to calls
-to `operator delete(void* ptr)` without affecting memory allocation. A
-conforming implementation is for
 `operator delete(void* ptr, std::size_t size)` to simply call
-`operator delete(ptr)`.
-*Default behavior:* the function
-`operator delete(void* ptr, std::size_t size)` calls
-`operator delete(ptr)`. See the note in the above *Replaceable*
-paragraph.
 *Default behavior:* If `ptr` is null, does nothing. Otherwise, reclaims
 the storage allocated by the earlier call to `operator new`.
 *Remarks:* It is unspecified under what conditions part or all of such
 reclaimed storage will be allocated by subsequent calls to
-`operator new` or any of `calloc`, `malloc`, or `realloc`, declared in
-`<cstdlib>`.
 ``` cpp
 void operator delete(void* ptr, const std::nothrow_t&) noexcept;
-void operator delete(void* ptr, std::size_t size, const std::nothrow_t&) noexcept;
 ```
-*Effects:* The *deallocation
-function* ([[basic.stc.dynamic.deallocation]]) called by the
 implementation to render the value of `ptr` invalid when the constructor
 invoked from a nothrow placement version of the *new-expression* throws
 an exception.
-*Replaceable:* a C++program may define a function with signature
-`void operator delete(void* ptr, const std::nothrow_t&) noexcept` that
-displaces the default version defined by the C++standard library. If
-this function (without `size` parameter) is defined, the program should
-also define
-`void operator delete(void* ptr, std::size_t size, const std::nothrow_t&) noexcept`.
-If this function with `size` parameter is defined, the program shall
-also define the version without the `size` parameter. The default
-behavior below may change in the future, which will require replacing
-both deallocation functions when replacing the allocation function.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
-*Requires:* If present, the `std::size_t size` argument must equal the
-size argument passed to the allocation function that returned `ptr`.
-*Required behavior:* Calls to
-`operator delete(void* ptr, std::size_t size, const std::nothrow_t&)`
-may be changed to calls to
-`operator delete(void* ptr, const std::nothrow_t&)` without affecting
-memory allocation. A conforming implementation is for
-`operator delete(void* ptr, std::size_t size, const std::nothrow_t&)` to
-simply call `operator delete(void* ptr, const std::nothrow_t&)`.
-*Default behavior:*
-`operator delete(void* ptr, std::size_t size, const std::nothrow_t&)`
-calls `operator delete(ptr, std::nothrow)`, and
-`operator delete(void* ptr, const std::nothrow_t&)` calls
-`operator delete(ptr)`.
 #### Array forms <a id="new.delete.array">[[new.delete.array]]</a>
 ``` cpp
 void* operator new[](std::size_t size);
 ```
-*Effects:* The *allocation function* ([[basic.stc.dynamic.allocation]])
 called by the array form of a *new-expression* ([[expr.new]]) to
-allocate `size` bytes of storage suitably aligned to represent any array
-object of that size or smaller.[^33]
-*Replaceable:* a C++program can define a function with this function
-signature that displaces the default version defined by the C++standard
-library.
-*Required behavior:* Same as for `operator new(std::size_t)`. This
-requirement is binding on a replacement version of this function.
-*Default behavior:* Returns `operator new(size)`.
 ``` cpp
 void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
 ```
-*Effects:* Same as above, except that it is called by a placement
 version of a *new-expression* when a C++program prefers a null pointer
 result as an error indication, instead of a `bad_alloc` exception.
-*Replaceable:* a C++program can define a function with this function
-signature that displaces the default version defined by the C++standard
-library.
 *Required behavior:* Return a non-null pointer to suitably aligned
-storage ([[basic.stc.dynamic]]), or return a null pointer. This
-requirement is binding on a replacement version of this function.
-*Default behavior:* Calls `operator new[](size)`. If the call returns
 normally, returns the result of that call. Otherwise, returns a null
 pointer.
 ``` cpp
 void operator delete[](void* ptr) noexcept;
 void operator delete[](void* ptr, std::size_t size) noexcept;
 ```
-*Effects:* The *deallocation
-function* ([[basic.stc.dynamic.deallocation]]) called by the array form
 of a *delete-expression* to render the value of `ptr` invalid.
-*Replaceable:* a C++program can define a function with signature
-`void operator delete[](void* ptr) noexcept` that displaces the default
-version defined by the C++standard library. If this function (without
-`size` parameter) is defined, the program should also define
-`void operator delete[](void* ptr, std::size_t size) noexcept`. If this
-function with `size` parameter is defined, the program shall also define
-the version without the `size` parameter. The default behavior below may
-change in the future, which will require replacing both deallocation
-functions when replacing the allocation function.
-*Requires:* *ptr* shall be a null pointer or its value shall be the
-value returned by an earlier call to `operator new[](std::size_t)` or
-`operator new[](std::size_t,const std::nothrow_t&)` which has not been
-invalidated by an intervening call to `operator delete[](void*)`.
-*Requires:* If present, the `std::size_t size` argument must equal the
-size argument passed to the allocation function that returned `ptr`.
-*Required behavior:* Calls to
-`operator delete[](void* ptr, std::size_t size)` may be changed to calls
-to `operator delete[](void* ptr)` without affecting memory allocation. A
-conforming implementation is for
 `operator delete[](void* ptr, std::size_t size)` to simply call
-`operator delete[](void* ptr)`.
-*Requires:* If an implementation has strict pointer
-safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
-safely-derived pointer.
-*Default behavior:* `operator delete[](void* ptr, std::size_t size)`
-calls `operator delete[](ptr)`, and `operator delete[](void* ptr)` calls
-`operator delete(ptr)`.
 ``` cpp
 void operator delete[](void* ptr, const std::nothrow_t&) noexcept;
-void operator delete[](void* ptr, std::size_t size, const std::nothrow_t&) noexcept;
 ```
-*Effects:* The *deallocation
-function* ([[basic.stc.dynamic.deallocation]]) called by the
 implementation to render the value of `ptr` invalid when the constructor
 invoked from a nothrow placement version of the array *new-expression*
 throws an exception.
-*Replaceable:* a C++program may define a function with signature
-`void operator delete[](void* ptr, const std::nothrow_t&) noexcept` that
-displaces the default version defined by the C++standard library. If
-this function (without `size` parameter) is defined, the program should
-also define
-`void operator delete[](void* ptr, std::size_t size, const std::nothrow_t&) noexcept`.
-If this function with `size` parameter is defined, the program shall
-also define the version without the `size` parameter. The default
-behavior below may change in the future, which will require replacing
-both deallocation functions when replacing the allocation function.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
-*Requires:* If present, the `std::size_t size` argument must equal the
-size argument passed to the allocation function that returned `ptr`.
-*Required behavior:* Calls to
-`operator delete[](void* ptr, std::size_t size, const std::nothrow_t&)`
-may be changed to calls to
-`operator delete[](void* ptr, const std::nothrow_t&)` without affecting
-memory allocation. A conforming implementation is for
-`operator delete[](void* ptr, std::size_t size, const std::nothrow_t&)`
-to simply call `operator delete[](void* ptr, const std::nothrow_t&)`.
-*Default behavior:*
-`operator delete[](void* ptr, std::size_t size, const std::nothrow_t&)`
-calls `operator delete[](ptr, std::nothrow)`, and
-`operator delete[](void* ptr, const std::nothrow_t&)` calls
-`operator delete[](ptr)`.
-#### Placement forms <a id="new.delete.placement">[[new.delete.placement]]</a>
-These functions are reserved, a C++program may not define functions that
-displace the versions in the Standard C++library ([[constraints]]). The
-provisions of ([[basic.stc.dynamic]]) do not apply to these reserved
 placement forms of `operator new` and `operator delete`.
 ``` cpp
 void* operator new(std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
 This can be useful for constructing an object at a known address:
 ``` cpp
 void* place = operator new(sizeof(Something));
 Something* p = new (place) Something();
 ```
 ``` cpp
 void* operator new[](std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
@@ -324,11 +363,11 @@ void operator delete(void* ptr, void*) noexcept;
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
 *Remarks:* Default function called when any part of the initialization
-in a placement new expression that invokes the library’s non-array
 placement operator new terminates by throwing an
 exception ([[expr.new]]).
 ``` cpp
 void operator delete[](void* ptr, void*) noexcept;
@@ -339,21 +378,23 @@ void operator delete[](void* ptr, void*) noexcept;
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
 *Remarks:* Default function called when any part of the initialization
-in a placement new expression that invokes the library’s array placement
-operator new terminates by throwing an exception ([[expr.new]]).
 #### Data races <a id="new.delete.dataraces">[[new.delete.dataraces]]</a>
 For purposes of determining the existence of data races, the library
 versions of `operator new`, user replacement versions of global
-`operator new`, the C standard library functions `calloc` and `malloc`,
-the library versions of `operator delete`, user replacement versions of
-`operator delete`, the C standard library function `free`, and the C
-standard library function `realloc` shall not introduce a data race (
-[[res.on.data.races]]). Calls to these functions that allocate or
-deallocate a particular unit of storage shall occur in a single total
-order, and each such deallocation call shall happen before (
-[[intro.multithread]]) the next allocation (if any) in this order.

 ### Storage allocation and deallocation <a id="new.delete">[[new.delete]]</a>
+Except where otherwise specified, the provisions of
+[[basic.stc.dynamic]] apply to the library versions of `operator new`
 and `operator
+delete`. If the value of an alignment argument passed to any of these
+functions is not a valid alignment value, the behavior is undefined.
 #### Single-object forms <a id="new.delete.single">[[new.delete.single]]</a>
 ``` cpp
 void* operator new(std::size_t size);
+void* operator new(std::size_t size, std::align_val_t alignment);
 ```
+*Effects:* The allocation functions ([[basic.stc.dynamic.allocation]])
 called by a *new-expression* ([[expr.new]]) to allocate `size` bytes of
+storage. The second form is called for a type with new-extended
+alignment, and allocates storage with the specified alignment. The first
+form is called otherwise, and allocates storage suitably aligned to
+represent any object of that size provided the object’s type does not
+have new-extended alignment.
+*Replaceable:* A C++program may define functions with either of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
 *Required behavior:* Return a non-null pointer to suitably aligned
 storage ([[basic.stc.dynamic]]), or else throw a `bad_alloc` exception.
+This requirement is binding on any replacement versions of these
+functions.
 *Default behavior:*
 - Executes a loop: Within the loop, the function first attempts to
   allocate the requested storage. Whether the attempt involves a call to
+  the C standard library functions `malloc` or `aligned_alloc` is
+  unspecified.
 - Returns a pointer to the allocated storage if the attempt is
   successful. Otherwise, if the current
   `new_handler` ([[get.new.handler]]) is a null pointer value, throws
   `bad_alloc`.
 - Otherwise, the function calls the current `new_handler`
 - The loop terminates when an attempt to allocate the requested storage
   is successful or when a called `new_handler` function does not return.
 ``` cpp
 void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
+void* operator new(std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
+*Effects:* Same as above, except that these are called by a placement
 version of a *new-expression* when a C++program prefers a null pointer
 result as an error indication, instead of a `bad_alloc` exception.
+*Replaceable:* A C++program may define functions with either of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
 *Required behavior:* Return a non-null pointer to suitably aligned
+storage ([[basic.stc.dynamic]]), or else return a null pointer. Each of
+these nothrow versions of `operator new` returns a pointer obtained as
+if acquired from the (possibly replaced) corresponding non-placement
+function. This requirement is binding on any replacement versions of
+these functions.
+*Default behavior:* Calls `operator new(size)`, or
+`operator new(size, alignment)`, respectively. If the call returns
 normally, returns the result of that call. Otherwise, returns a null
 pointer.
+[*Example 1*:
 ``` cpp
 T* p1 = new T;                  // throws bad_alloc if it fails
 T* p2 = new(nothrow) T;         // returns nullptr if it fails
 ```
+— *end example*]
 ``` cpp
 void operator delete(void* ptr) noexcept;
 void operator delete(void* ptr, std::size_t size) noexcept;
+void operator delete(void* ptr, std::align_val_t alignment) noexcept;
+void operator delete(void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
 ```
+*Effects:* The deallocation
+functions ([[basic.stc.dynamic.deallocation]]) called by a
 *delete-expression* to render the value of `ptr` invalid.
+*Replaceable:* A C++program may define functions with any of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
+If a function without a `size` parameter is defined, the program should
+also define the corresponding function with a `size` parameter. If a
+function with a `size` parameter is defined, the program shall also
+define the corresponding version without the `size` parameter.
+[*Note 1*: The default behavior below may change in the future, which
+will require replacing both deallocation functions when replacing the
+allocation function. — *end note*]
+*Requires:* `ptr` shall be a null pointer or its value shall represent
+the address of a block of memory allocated by an earlier call to a
+(possibly replaced) `operator new(std::size_t)` or
+`operator new(std::size_t, std::align_val_t)` which has not been
+invalidated by an intervening call to `operator delete`.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
+*Requires:* If the `alignment` parameter is not present, `ptr` shall
+have been returned by an allocation function without an `alignment`
+parameter. If present, the `alignment` argument shall equal the
+`alignment` argument passed to the allocation function that returned
+`ptr`. If present, the `size` argument shall equal the `size` argument
+passed to the allocation function that returned `ptr`.
+*Required behavior:* A call to an `operator delete` with a `size`
+parameter may be changed to a call to the corresponding
+`operator delete` without a `size` parameter, without affecting memory
+allocation.
+[*Note 2*: A conforming implementation is for
 `operator delete(void* ptr, std::size_t size)` to simply call
+`operator delete(ptr)`. — *end note*]
+*Default behavior:* The functions that have a `size` parameter forward
+their other parameters to the corresponding function without a `size`
+parameter.
+[*Note 3*: See the note in the above *Replaceable:*
+paragraph. — *end note*]
 *Default behavior:* If `ptr` is null, does nothing. Otherwise, reclaims
 the storage allocated by the earlier call to `operator new`.
 *Remarks:* It is unspecified under what conditions part or all of such
 reclaimed storage will be allocated by subsequent calls to
+`operator new` or any of `aligned_alloc`, `calloc`, `malloc`, or
+`realloc`, declared in `<cstdlib>`.
 ``` cpp
 void operator delete(void* ptr, const std::nothrow_t&) noexcept;
+void operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
+*Effects:* The deallocation
+functions ([[basic.stc.dynamic.deallocation]]) called by the
 implementation to render the value of `ptr` invalid when the constructor
 invoked from a nothrow placement version of the *new-expression* throws
 an exception.
+*Replaceable:* A C++program may define functions with either of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
+*Requires:* `ptr` shall be a null pointer or its value shall represent
+the address of a block of memory allocated by an earlier call to a
+(possibly replaced) `operator new(std::size_t)` or
+`operator new(std::size_t, std::align_val_t)` which has not been
+invalidated by an intervening call to `operator delete`.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
+*Requires:* If the `alignment` parameter is not present, `ptr` shall
+have been returned by an allocation function without an `alignment`
+parameter. If present, the `alignment` argument shall equal the
+`alignment` argument passed to the allocation function that returned
+`ptr`.
+*Default behavior:* Calls `operator delete(ptr)`, or
+`operator delete(ptr, alignment)`, respectively.
 #### Array forms <a id="new.delete.array">[[new.delete.array]]</a>
 ``` cpp
 void* operator new[](std::size_t size);
+void* operator new[](std::size_t size, std::align_val_t alignment);
 ```
+*Effects:* The allocation functions ([[basic.stc.dynamic.allocation]])
 called by the array form of a *new-expression* ([[expr.new]]) to
+allocate `size` bytes of storage. The second form is called for a type
+with new-extended alignment, and allocates storage with the specified
+alignment. The first form is called otherwise, and allocates storage
+suitably aligned to represent any array object of that size or smaller,
+provided the object’s type does not have new-extended alignment. [^33]
+*Replaceable:* A C++program may define functions with either of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
+*Required behavior:* Same as for the corresponding single-object forms.
+This requirement is binding on any replacement versions of these
+functions.
+*Default behavior:* Returns `operator new(size)`, or
+`operator new(size, alignment)`, respectively.
 ``` cpp
 void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
+void* operator new[](std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
+*Effects:* Same as above, except that these are called by a placement
 version of a *new-expression* when a C++program prefers a null pointer
 result as an error indication, instead of a `bad_alloc` exception.
+*Replaceable:* A C++program may define functions with either of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
 *Required behavior:* Return a non-null pointer to suitably aligned
+storage ([[basic.stc.dynamic]]), or else return a null pointer. Each of
+these nothrow versions of `operator new[]` returns a pointer obtained as
+if acquired from the (possibly replaced) corresponding non-placement
+function. This requirement is binding on any replacement versions of
+these functions.
+*Default behavior:* Calls `operator new[](size)`, or
+`operator new[](size, alignment)`, respectively. If the call returns
 normally, returns the result of that call. Otherwise, returns a null
 pointer.
 ``` cpp
 void operator delete[](void* ptr) noexcept;
 void operator delete[](void* ptr, std::size_t size) noexcept;
+void operator delete[](void* ptr, std::align_val_t alignment) noexcept;
+void operator delete[](void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
 ```
+*Effects:* The deallocation
+functions ([[basic.stc.dynamic.deallocation]]) called by the array form
 of a *delete-expression* to render the value of `ptr` invalid.
+*Replaceable:* A C++program may define functions with any of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
+If a function without a `size` parameter is defined, the program should
+also define the corresponding function with a `size` parameter. If a
+function with a `size` parameter is defined, the program shall also
+define the corresponding version without the `size` parameter.
+[*Note 1*: The default behavior below may change in the future, which
+will require replacing both deallocation functions when replacing the
+allocation function. — *end note*]
+*Requires:* `ptr` shall be a null pointer or its value shall represent
+the address of a block of memory allocated by an earlier call to a
+(possibly replaced) `operator new[](std::size_t)` or
+`operator new[](std::size_t, std::align_val_t)` which has not been
+invalidated by an intervening call to `operator delete[]`.
+*Requires:* If an implementation has strict pointer
+safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
+safely-derived pointer.
+*Requires:* If the `alignment` parameter is not present, `ptr` shall
+have been returned by an allocation function without an `alignment`
+parameter. If present, the `alignment` argument shall equal the
+`alignment` argument passed to the allocation function that returned
+`ptr`. If present, the `size` argument shall equal the `size` argument
+passed to the allocation function that returned `ptr`.
+*Required behavior:* A call to an `operator delete[]` with a `size`
+parameter may be changed to a call to the corresponding
+`operator delete[]` without a `size` parameter, without affecting memory
+allocation.
+[*Note 2*: A conforming implementation is for
 `operator delete[](void* ptr, std::size_t size)` to simply call
+`operator delete[](ptr)`. — *end note*]
+*Default behavior:* The functions that have a `size` parameter forward
+their other parameters to the corresponding function without a `size`
+parameter. The functions that do not have a `size` parameter forward
+their parameters to the corresponding `operator delete` (single-object)
+function.
 ``` cpp
 void operator delete[](void* ptr, const std::nothrow_t&) noexcept;
+void operator delete[](void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
+*Effects:* The deallocation
+functions ([[basic.stc.dynamic.deallocation]]) called by the
 implementation to render the value of `ptr` invalid when the constructor
 invoked from a nothrow placement version of the array *new-expression*
 throws an exception.
+*Replaceable:* A C++program may define functions with either of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
+*Requires:* `ptr` shall be a null pointer or its value shall represent
+the address of a block of memory allocated by an earlier call to a
+(possibly replaced) `operator new[](std::size_t)` or
+`operator new[](std::size_t, std::align_val_t)` which has not been
+invalidated by an intervening call to `operator delete[]`.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
+*Requires:* If the `alignment` parameter is not present, `ptr` shall
+have been returned by an allocation function without an `alignment`
+parameter. If present, the `alignment` argument shall equal the
+`alignment` argument passed to the allocation function that returned
+`ptr`.
+*Default behavior:* Calls `operator delete[](ptr)`, or
+`operator delete[](ptr, alignment)`, respectively.
+#### Non-allocating forms <a id="new.delete.placement">[[new.delete.placement]]</a>
+These functions are reserved; a C++program may not define functions that
+displace the versions in the C++standard library ([[constraints]]). The
+provisions of  [[basic.stc.dynamic]] do not apply to these reserved
 placement forms of `operator new` and `operator delete`.
 ``` cpp
 void* operator new(std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
+[*Example 1*:
 This can be useful for constructing an object at a known address:
 ``` cpp
 void* place = operator new(sizeof(Something));
 Something* p = new (place) Something();
 ```
+— *end example*]
 ``` cpp
 void* operator new[](std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
 *Remarks:* Default function called when any part of the initialization
+in a placement *new-expression* that invokes the library’s non-array
 placement operator new terminates by throwing an
 exception ([[expr.new]]).
 ``` cpp
 void operator delete[](void* ptr, void*) noexcept;
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
 *Remarks:* Default function called when any part of the initialization
+in a placement *new-expression* that invokes the library’s array
+placement operator new terminates by throwing an
+exception ([[expr.new]]).
 #### Data races <a id="new.delete.dataraces">[[new.delete.dataraces]]</a>
 For purposes of determining the existence of data races, the library
 versions of `operator new`, user replacement versions of global
+`operator new`, the C standard library functions `aligned_alloc`,
+`calloc`, and `malloc`, the library versions of `operator delete`, user
+replacement versions of `operator delete`, the C standard library
+function `free`, and the C standard library function `realloc` shall not
+introduce a data race ([[res.on.data.races]]). Calls to these functions
+that allocate or deallocate a particular unit of storage shall occur in
+a single total order, and each such deallocation call shall happen
+before ([[intro.multithread]]) the next allocation (if any) in this
+order.

Diff to HTML by rtfpessoa