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

Files changed (1) hide show

tmp/tmp8dhzkahw/{from.md → to.md} +42 -47

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

@@ -1,48 +1,45 @@
 #### 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.
@@ -50,11 +47,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.
@@ -77,13 +74,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.
@@ -94,26 +91,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.
@@ -140,34 +137,32 @@ 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.

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

Diff to HTML by rtfpessoa