[new.delete] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpm4vst13c/{from.md → to.md} +62 -66

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

@@ -6,26 +6,37 @@ 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
-[[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.
@@ -42,24 +53,21 @@ functions.
   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
@@ -77,10 +85,12 @@ 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;
@@ -101,46 +111,43 @@ returned `ptr`.
 *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.
-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 might change in the future, which
-will require replacing both deallocation functions when replacing the
-allocation function. — *end note*]
 *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;
 ```
@@ -159,54 +166,45 @@ allocation function that returned `ptr`.
 *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.
 *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.[^31]
-*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
-[[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
@@ -215,10 +213,12 @@ 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;
@@ -239,38 +239,36 @@ returned `ptr`.
 *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 might change in the future, which
-will require replacing both deallocation functions when replacing the
-allocation function. — *end note*]
 *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;
 ```
@@ -288,26 +286,24 @@ allocation function that returned `ptr`.
 *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.
 *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.
@@ -322,11 +318,11 @@ Something* p = new (place) Something();
 ```
 — *end example*]
 ``` cpp
-[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.

 [[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.
+On freestanding implementations, it is *implementation-defined* whether
+the default versions of the replaceable global allocation functions
+satisfy the required behaviors described in [[new.delete.single]] and
+[[new.delete.array]].
+[*Note 1*: A freestanding implementation’s default versions of the
+replaceable global allocation functions can cause undefined behavior
+when invoked. During constant evaluation, the behaviors of those default
+versions are irrelevant, as those calls are omitted
+[[expr.new]]. — *end note*]
+*Recommended practice:* If any of the default versions of the
+replaceable global allocation functions meet the requirements of a
+hosted implementation, they all should.
 #### 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 the first form is called otherwise.
 *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.
   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.
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 ``` 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.
 *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
 T* p2 = new(nothrow) T;         // returns nullptr if it fails
 ```
 — *end example*]
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 ``` 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*[[expr.delete]] to render the value of
 `ptr` invalid.
 *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 1*: 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 2*: See the note in the below *Remarks:*
 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>`. This function is
+replaceable [[term.replaceable.function]]. If a replacement function
+without a `size` parameter is defined by the program, the program should
+also define the corresponding function with a `size` parameter. If a
+replacement function with a `size` parameter is defined by the program,
+the program shall also define the corresponding version without the
+`size` parameter.
+[*Note 3*: The default behavior above might change in the future, which
+will require replacing both deallocation functions when replacing the
+allocation function. — *end note*]
 ``` 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.
 *Default behavior:* Calls `operator delete(ptr)`, or
 `operator delete(ptr, alignment)`, respectively.
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 #### 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 the first form is called otherwise.[^31]
 *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.
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 ``` 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.
 *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
 *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.
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 ``` 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.
 *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 1*: 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.
+*Remarks:* This function is replaceable [[term.replaceable.function]].
+If a replacement function without a `size` parameter is defined by the
+program, the program should also define the corresponding function with
+a `size` parameter. If a replacement function with a `size` parameter is
+defined by the program, the program shall also define the corresponding
+version without the `size` parameter.
+[*Note 2*: The default behavior above might change in the future, which
+will require replacing both deallocation functions when replacing the
+allocation function. — *end note*]
 ``` 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.
 *Default behavior:* Calls `operator delete[](ptr)`, or
 `operator delete[](ptr, alignment)`, respectively.
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 #### 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
+constexpr void* operator new(std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
 ```
 — *end example*]
 ``` cpp
+constexpr void* operator new[](std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.

Diff to HTML by rtfpessoa