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

Files changed (1) hide show

tmp/tmptwtftzst/{from.md → to.md} +23 -33

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

@@ -1,21 +1,17 @@
 #### 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.
@@ -32,24 +28,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
@@ -67,10 +60,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;
@@ -91,46 +86,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;
 ```
@@ -149,12 +141,10 @@ 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.

 #### 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]].

Diff to HTML by rtfpessoa