[default.allocator] - C++20 → C++23

Files changed (1) hide show

tmp/tmps4aypen4/{from.md → to.md} +36 -6

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

@@ -1,7 +1,9 @@
 ### The default allocator <a id="default.allocator">[[default.allocator]]</a>
 All specializations of the default allocator meet the allocator
 completeness requirements [[allocator.requirements.completeness]].
 ``` cpp
 namespace std {
@@ -9,24 +11,28 @@ namespace std {
    public:
     using value_type                             = T;
     using size_type                              = size_t;
     using difference_type                        = ptrdiff_t;
     using propagate_on_container_move_assignment = true_type;
-    using is_always_equal                        = true_type;
     constexpr allocator() noexcept;
     constexpr allocator(const allocator&) noexcept;
     template<class U> constexpr allocator(const allocator<U>&) noexcept;
     constexpr ~allocator();
     constexpr allocator& operator=(const allocator&) = default;
     [[nodiscard]] constexpr T* allocate(size_t n);
     constexpr void deallocate(T* p, size_t n);
   };
 }
 ```
 #### Members <a id="allocator.members">[[allocator.members]]</a>
 Except for the destructor, member functions of the default allocator
 shall not introduce data races [[intro.multithread]] as a result of
 concurrent calls to those member functions from different threads. Calls
@@ -36,30 +42,54 @@ call shall happen before the next allocation (if any) in this order.
 ``` cpp
 [[nodiscard]] constexpr T* allocate(size_t n);
 ```
-*Mandates:* `T` is not an incomplete type [[basic.types]].
 *Returns:* A pointer to the initial element of an array of `n` `T`.
 *Remarks:* The storage for the array is obtained by calling
 `::operator new` [[new.delete]], but it is unspecified when or how often
 this function is called. This function starts the lifetime of the array
 object, but not that of any of the array elements.
 *Throws:* `bad_array_new_length` if
-`numeric_limits<size_t>::max() / sizeof(T) < n`, or `bad_alloc` if the
 storage cannot be obtained.
 ``` cpp
 constexpr void deallocate(T* p, size_t n);
 ```
-*Preconditions:* `p` is a pointer value obtained from `allocate()`. `n`
-equals the value passed as the first argument to the invocation of
-allocate which returned `p`.
 *Effects:* Deallocates the storage referenced by `p`.
 *Remarks:* Uses `::operator delete` [[new.delete]], but it is
 unspecified when this function is called.

 ### The default allocator <a id="default.allocator">[[default.allocator]]</a>
+#### General <a id="default.allocator.general">[[default.allocator.general]]</a>
 All specializations of the default allocator meet the allocator
 completeness requirements [[allocator.requirements.completeness]].
 ``` cpp
 namespace std {
    public:
     using value_type                             = T;
     using size_type                              = size_t;
     using difference_type                        = ptrdiff_t;
     using propagate_on_container_move_assignment = true_type;
     constexpr allocator() noexcept;
     constexpr allocator(const allocator&) noexcept;
     template<class U> constexpr allocator(const allocator<U>&) noexcept;
     constexpr ~allocator();
     constexpr allocator& operator=(const allocator&) = default;
     [[nodiscard]] constexpr T* allocate(size_t n);
+    [[nodiscard]] constexpr allocation_result<T*> allocate_at_least(size_t n);
     constexpr void deallocate(T* p, size_t n);
   };
 }
 ```
+`allocator_traits<allocator<T>>::is_always_equal::value`
+is `true` for any `T`.
 #### Members <a id="allocator.members">[[allocator.members]]</a>
 Except for the destructor, member functions of the default allocator
 shall not introduce data races [[intro.multithread]] as a result of
 concurrent calls to those member functions from different threads. Calls
 ``` cpp
 [[nodiscard]] constexpr T* allocate(size_t n);
 ```
+*Mandates:* `T` is not an incomplete type [[term.incomplete.type]].
 *Returns:* A pointer to the initial element of an array of `n` `T`.
+*Throws:* `bad_array_new_length` if
+`numeric_limits<size_t>::max() / sizeof(T) < n`, or `bad_alloc` if the
+storage cannot be obtained.
 *Remarks:* The storage for the array is obtained by calling
 `::operator new` [[new.delete]], but it is unspecified when or how often
 this function is called. This function starts the lifetime of the array
 object, but not that of any of the array elements.
+``` cpp
+[[nodiscard]] constexpr allocation_result<T*> allocate_at_least(size_t n);
+```
+*Mandates:* `T` is not an incomplete type [[term.incomplete.type]].
+*Returns:* `allocation_result<T*>{ptr, count}`, where `ptr` is a pointer
+to the initial element of an array of `count` `T` and `count` ≥ `n`.
 *Throws:* `bad_array_new_length` if
+`numeric_limits<size_t>::max() / sizeof(T)` < `n`, or `bad_alloc` if the
 storage cannot be obtained.
+*Remarks:* The storage for the array is obtained by calling
+`::operator new`, but it is unspecified when or how often this function
+is called. This function starts the lifetime of the array object, but
+not that of any of the array elements.
 ``` cpp
 constexpr void deallocate(T* p, size_t n);
 ```
+*Preconditions:*
+- If `p` is memory that was obtained by a call to `allocate_at_least`,
+  let `ret` be the value returned and `req` be the value passed as the
+  first argument to that call. `p` is equal to `ret.ptr` and `n` is a
+  value such that `req` ≤ `n` ≤ `ret.count`.
+- Otherwise, `p` is a pointer value obtained from `allocate`. `n` equals
+  the value passed as the first argument to the invocation of `allocate`
+  which returned `p`.
 *Effects:* Deallocates the storage referenced by `p`.
 *Remarks:* Uses `::operator delete` [[new.delete]], but it is
 unspecified when this function is called.

Diff to HTML by rtfpessoa