[support.dynamic] - C++20 → C++23

Files changed (1) hide show

tmp/tmp8icuwf44/{from.md → to.md} +62 -85

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

@@ -1,14 +1,17 @@
 ## Dynamic memory management <a id="support.dynamic">[[support.dynamic]]</a>
 The header `<new>` defines several functions that manage the allocation
 of dynamic storage in a program. It also defines components for
 reporting storage management errors.
 ### Header `<new>` synopsis <a id="new.syn">[[new.syn]]</a>
 ``` cpp
 namespace std {
   // [alloc.errors], storage allocation errors
   class bad_alloc;
   class bad_array_new_length;
@@ -73,10 +76,12 @@ void  operator delete  (void* ptr, void*) noexcept;
 void operator delete[](void* ptr, void*) noexcept;
 ```
 ### 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.
@@ -157,10 +162,23 @@ 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.
 *Replaceable:* A C++ program may define functions with any of these
@@ -170,31 +188,14 @@ 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*]
-*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.
@@ -220,34 +221,30 @@ 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.
-*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>
@@ -257,11 +254,11 @@ passed to the allocation function that returned `ptr`.
 ```
 *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.
@@ -303,10 +300,23 @@ 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
@@ -316,31 +326,14 @@ 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*]
-*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.
@@ -357,34 +350,30 @@ 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.
-*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>
@@ -424,28 +413,20 @@ Something* p = new (place) Something();
 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>
@@ -543,11 +524,11 @@ new_handler set_new_handler(new_handler new_p) noexcept;
 new_handler get_new_handler() noexcept;
 ```
 *Returns:* The current `new_handler`.
-[*Note 1*: This may be a null pointer value. — *end note*]
 ### Pointer optimization barrier <a id="ptr.launder">[[ptr.launder]]</a>
 ``` cpp
 template<class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;
@@ -556,22 +537,18 @@ template<class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;
 *Mandates:* `!is_function_v<T> && !is_void_v<T>` is `true`.
 *Preconditions:* `p` represents the address *A* of a byte in memory. An
 object *X* that is within its lifetime [[basic.life]] and whose type is
 similar [[conv.qual]] to `T` is located at the address *A*. All bytes of
-storage that would be reachable through the result are reachable through
-`p` (see below).
-*Returns:* A value of type `T*` that points to `X`.
 *Remarks:* An invocation of this function may be used in a core constant
-expression whenever the value of its argument may be used in a core
-constant expression. A byte of storage *b* is reachable through a
-pointer value that points to an object *Y* if there is an object *Z*,
-pointer-interconvertible with *Y*, such that *b* is within the storage
-occupied by *Z*, or the immediately-enclosing array object if *Z* is an
-array element.
 [*Note 1*: If a new object is created in storage occupied by an
 existing object of the same type, a pointer to the original object can
 be used to refer to the new object unless its complete object is a const
 object or it is a base class subobject; in the latter cases, this

 ## Dynamic memory management <a id="support.dynamic">[[support.dynamic]]</a>
+### General <a id="support.dynamic.general">[[support.dynamic.general]]</a>
 The header `<new>` defines several functions that manage the allocation
 of dynamic storage in a program. It also defines components for
 reporting storage management errors.
 ### Header `<new>` synopsis <a id="new.syn">[[new.syn]]</a>
 ``` cpp
+// all freestanding
 namespace std {
   // [alloc.errors], storage allocation errors
   class bad_alloc;
   class bad_array_new_length;
 void operator delete[](void* ptr, void*) noexcept;
 ```
 ### Storage allocation and deallocation <a id="new.delete">[[new.delete]]</a>
+#### General <a id="new.delete.general">[[new.delete.general]]</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.
 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;
 ```
+*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`.
+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`.
 *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
 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.
 ``` 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;
 ```
+*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`.
+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`.
 *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>
 ```
 *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.
 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;
 ```
+*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[]`.
+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`.
 *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
 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.
 ``` 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;
 ```
+*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[]`.
+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`.
 *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>
 void operator delete(void* ptr, void*) noexcept;
 ```
 *Effects:* Intentionally performs no action.
 *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.
 *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>
 new_handler get_new_handler() noexcept;
 ```
 *Returns:* The current `new_handler`.
+[*Note 1*: This can be a null pointer value. — *end note*]
 ### Pointer optimization barrier <a id="ptr.launder">[[ptr.launder]]</a>
 ``` cpp
 template<class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;
 *Mandates:* `!is_function_v<T> && !is_void_v<T>` is `true`.
 *Preconditions:* `p` represents the address *A* of a byte in memory. An
 object *X* that is within its lifetime [[basic.life]] and whose type is
 similar [[conv.qual]] to `T` is located at the address *A*. All bytes of
+storage that would be reachable through [[basic.compound]] the result
+are reachable through `p`.
+*Returns:* A value of type `T*` that points to *X*.
 *Remarks:* An invocation of this function may be used in a core constant
+expression if and only if the (converted) value of its argument may be
+used in place of the function invocation.
 [*Note 1*: If a new object is created in storage occupied by an
 existing object of the same type, a pointer to the original object can
 be used to refer to the new object unless its complete object is a const
 object or it is a base class subobject; in the latter cases, this

Diff to HTML by rtfpessoa