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

Files changed (1) hide show

tmp/tmpfmxfgg6k/{from.md → to.md} +96 -108

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

@@ -7,50 +7,47 @@ 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`
-  function ([[new.handler]]). If the called function returns, the loop
   repeats.
 - 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.
@@ -58,11 +55,11 @@ 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.
@@ -85,13 +82,13 @@ 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.
@@ -102,26 +99,26 @@ 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.
@@ -148,53 +145,48 @@ reclaimed storage will be allocated by subsequent calls to
 ``` 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.
@@ -204,12 +196,13 @@ 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.
@@ -217,11 +210,11 @@ 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.
@@ -235,13 +228,13 @@ 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.
@@ -252,26 +245,26 @@ 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.
@@ -289,48 +282,46 @@ 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.
@@ -345,11 +336,11 @@ Something* p = new (place) Something();
 ```
 — *end example*]
 ``` cpp
-void* operator new[](std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
@@ -358,43 +349,40 @@ void* operator new[](std::size_t size, void* ptr) noexcept;
 void operator delete(void* ptr, void*) noexcept;
 ```
 *Effects:* Intentionally performs no action.
-*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;
 ```
 *Effects:* Intentionally performs no action.
-*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.

 functions is not a valid alignment value, the behavior is undefined.
 #### Single-object forms <a id="new.delete.single">[[new.delete.single]]</a>
 ``` cpp
+[[nodiscard]] void* operator new(std::size_t size);
+[[nodiscard]] 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 the first form is called otherwise.
 *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`
+  function [[new.handler]]. If the called function returns, the loop
   repeats.
 - The loop terminates when an attempt to allocate the requested storage
   is successful or when a called `new_handler` function does not return.
 ``` cpp
+[[nodiscard]] void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
+[[nodiscard]] 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.
 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*[[expr.delete]] 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.
 [*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*]
+*Preconditions:* `ptr` is a null pointer or its value represents 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`.
+*Preconditions:* If an implementation has strict pointer
+safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
+pointer.
+*Preconditions:* If the `alignment` parameter is not present, `ptr` was
+returned by an allocation function without an `alignment` parameter. If
+present, the `alignment` argument is equal to the `alignment` argument
+passed to the allocation function that returned `ptr`. If present, the
+`size` argument is equal to 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.
 ``` 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.
+*Preconditions:* `ptr` is a null pointer or its value represents 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`.
+*Preconditions:* If an implementation has strict pointer
+safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
+pointer.
+*Preconditions:* If the `alignment` parameter is not present, `ptr` was
+returned by an allocation function without an `alignment` parameter. If
+present, the `alignment` argument is equal to 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
+[[nodiscard]] void* operator new[](std::size_t size);
+[[nodiscard]] 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 the first form is called otherwise. [^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.
 *Default behavior:* Returns `operator new(size)`, or
 `operator new(size, alignment)`, respectively.
 ``` cpp
+[[nodiscard]] void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
+[[nodiscard]] 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.
 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.
 [*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*]
+*Preconditions:* `ptr` is a null pointer or its value represents 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[]`.
+*Preconditions:* If an implementation has strict pointer
+safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
+pointer.
+*Preconditions:* If the `alignment` parameter is not present, `ptr` was
+returned by an allocation function without an `alignment` parameter. If
+present, the `alignment` argument is equal to the `alignment` argument
+passed to the allocation function that returned `ptr`. If present, the
+`size` argument is equal to 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.
 ``` 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.
+*Preconditions:* `ptr` is a null pointer or its value represents 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[]`.
+*Preconditions:* If an implementation has strict pointer
+safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
+pointer.
+*Preconditions:* If the `alignment` parameter is not present, `ptr` was
+returned by an allocation function without an `alignment` parameter. If
+present, the `alignment` argument is equal to 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
+[[nodiscard]] void* operator new(std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
 ```
 — *end example*]
 ``` cpp
+[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
 void operator delete(void* ptr, void*) noexcept;
 ```
 *Effects:* Intentionally performs no action.
+*Preconditions:* If an implementation has strict pointer
+safety [[basic.stc.dynamic.safety]] then `ptr` is 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;
 ```
 *Effects:* Intentionally performs no action.
+*Preconditions:* If an implementation has strict pointer
+safety [[basic.stc.dynamic.safety]] then `ptr` is 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