[mem.poly.allocator.mem] - C++17 → C++20

Files changed (1) hide show

tmp/tmp7erteob1/{from.md → to.md} +88 -115

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

@@ -1,150 +1,123 @@
-#### `polymorphic_allocator` member functions <a id="mem.poly.allocator.mem">[[mem.poly.allocator.mem]]</a>
 ``` cpp
-Tp* allocate(size_t n);
 ```
-*Returns:* Equivalent to
 ``` cpp
 return static_cast<Tp*>(memory_rsrc->allocate(n * sizeof(Tp), alignof(Tp)));
 ```
 ``` cpp
 void deallocate(Tp* p, size_t n);
 ```
-*Requires:* `p` was allocated from a memory resource `x`, equal to
 `*memory_rsrc`, using `x.allocate(n * sizeof(Tp), alignof(Tp))`.
 *Effects:* Equivalent to
 `memory_rsrc->deallocate(p, n * sizeof(Tp), alignof(Tp))`.
 *Throws:* Nothing.
 ``` cpp
 template<class T, class... Args>
   void construct(T* p, Args&&... args);
 ```
-*Requires:* Uses-allocator construction of `T` with allocator
-`resource()` (see  [[allocator.uses.construction]]) and constructor
-arguments `std::forward<Args>(args)...` is well-formed.
-[*Note 1*: Uses-allocator construction is always well formed for types
-that do not use allocators. — *end note*]
 *Effects:* Construct a `T` object in the storage whose address is
-represented by `p` by uses-allocator construction with allocator
-`resource()` and constructor arguments `std::forward<Args>(args)...`.
 *Throws:* Nothing unless the constructor for `T` throws.
-``` cpp
-template <class T1, class T2, class... Args1, class... Args2>
-  void construct(pair<T1,T2>* p, piecewise_construct_t,
-                 tuple<Args1...> x, tuple<Args2...> y);
-```
-[*Note 2*: This method and the `construct` methods that follow are
-overloads for piecewise construction of
-pairs ([[pairs.pair]]). — *end note*]
-*Effects:* Let `xprime` be a `tuple` constructed from `x` according to
-the appropriate rule from the following list.
-[*Note 3*: The following description can be summarized as constructing
-a `pair<T1, T2>` object in the storage whose address is represented by
-`p`, as if by separate uses-allocator construction with allocator
-`resource()` ([[allocator.uses.construction]]) of `p->first` using the
-elements of `x` and `p->second` using the elements of
-`y`. — *end note*]
-- If `uses_allocator_v<T1,memory_resource*>` is `false`
-  and `is_constructible_v<T1,Args1...>` is `true`,
-  then `xprime` is `x`.
-- Otherwise, if `uses_allocator_v<T1,memory_resource*>` is `true`
-  and `is_constructible_v<T1,allocator_arg_t,memory_resource*,Args1...>`
-  is `true`,
-  then `xprime` is
-  `tuple_cat(make_tuple(allocator_arg, resource()), std::move(x))`.
-- Otherwise, if `uses_allocator_v<T1,memory_resource*>` is `true`
-  and `is_constructible_v<T1,Args1...,memory_resource*>` is `true`,
-  then `xprime` is `tuple_cat(std::move(x), make_tuple(resource()))`.
-- Otherwise the program is ill formed.
-Let `yprime` be a tuple constructed from `y` according to the
-appropriate rule from the following list:
-- If `uses_allocator_v<T2,memory_resource*>` is `false`
-  and `is_constructible_v<T2,Args2...>` is `true`,
-  then `yprime` is `y`.
-- Otherwise, if `uses_allocator_v<T2,memory_resource*>` is `true`
-  and `is_constructible_v<T2,allocator_arg_t,memory_resource*,Args2...>`
-  is `true`,
-  then `yprime` is
-  `tuple_cat(make_tuple(allocator_arg, resource()), std::move(y))`.
-- Otherwise, if `uses_allocator_v<T2,memory_resource*>` is `true`
-  and `is_constructible_v<T2,Args2...,memory_resource*>` is `true`,
-  then `yprime` is `tuple_cat(std::move(y), make_tuple(resource()))`.
-- Otherwise the program is ill formed.
-Then, using `piecewise_construct`, `xprime`, and `yprime` as the
-constructor arguments, this function constructs a `pair<T1, T2>` object
-in the storage whose address is represented by `p`.
-``` cpp
-template <class T1, class T2>
-  void construct(pair<T1,T2>* p);
-```
-*Effects:* Equivalent to:
-``` cpp
-construct(p, piecewise_construct, tuple<>(), tuple<>());
-```
-``` cpp
-template <class T1, class T2, class U, class V>
-  void construct(pair<T1,T2>* p, U&& x, V&& y);
-```
-*Effects:* Equivalent to:
-``` cpp
-construct(p, piecewise_construct,
-          forward_as_tuple(std::forward<U>(x)),
-          forward_as_tuple(std::forward<V>(y)));
-```
-``` cpp
-template <class T1, class T2, class U, class V>
-  void construct(pair<T1,T2>* p, const pair<U, V>& pr);
-```
-*Effects:* Equivalent to:
-``` cpp
-construct(p, piecewise_construct,
-          forward_as_tuple(pr.first),
-          forward_as_tuple(pr.second));
-```
-``` cpp
-template <class T1, class T2, class U, class V>
-  void construct(pair<T1,T2>* p, pair<U, V>&& pr);
-```
-*Effects:* Equivalent to:
-``` cpp
-construct(p, piecewise_construct,
-          forward_as_tuple(std::forward<U>(pr.first)),
-          forward_as_tuple(std::forward<V>(pr.second)));
-```
 ``` cpp
 template<class T>
   void destroy(T* p);
 ```

+#### Member functions <a id="mem.poly.allocator.mem">[[mem.poly.allocator.mem]]</a>
 ``` cpp
+[[nodiscard]] Tp* allocate(size_t n);
 ```
+*Effects:* If `numeric_limits<size_t>::max() / sizeof(Tp) < n`, throws
+`bad_array_new_length`. Otherwise equivalent to:
 ``` cpp
 return static_cast<Tp*>(memory_rsrc->allocate(n * sizeof(Tp), alignof(Tp)));
 ```
 ``` cpp
 void deallocate(Tp* p, size_t n);
 ```
+*Preconditions:* `p` was allocated from a memory resource `x`, equal to
 `*memory_rsrc`, using `x.allocate(n * sizeof(Tp), alignof(Tp))`.
 *Effects:* Equivalent to
 `memory_rsrc->deallocate(p, n * sizeof(Tp), alignof(Tp))`.
 *Throws:* Nothing.
+``` cpp
+[[nodiscard]] void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));
+```
+*Effects:* Equivalent to:
+`return memory_rsrc->allocate(nbytes, alignment);`
+[*Note 1*: The return type is `void*` (rather than, e.g., `byte*`) to
+support conversion to an arbitrary pointer type `U*` by
+`static_cast<U*>`, thus facilitating construction of a `U` object in the
+allocated memory. — *end note*]
+``` cpp
+void deallocate_bytes(void* p, size_t nbytes, size_t alignment = alignof(max_align_t));
+```
+*Effects:* Equivalent to
+`memory_rsrc->deallocate(p, nbytes, alignment)`.
+``` cpp
+template<class T>
+  [[nodiscard]] T* allocate_object(size_t n = 1);
+```
+*Effects:* Allocates memory suitable for holding an array of `n` objects
+of type `T`, as follows:
+- if `numeric_limits<size_t>::max() / sizeof(T) < n`, throws
+  `bad_array_new_length`,
+- otherwise equivalent to:
+  ``` cpp
+  return static_cast<T*>(allocate_bytes(n*sizeof(T), alignof(T)));
+  ```
+[*Note 2*: `T` is not deduced and must therefore be provided as a
+template argument. — *end note*]
+``` cpp
+template<class T>
+  void deallocate_object(T* p, size_t n = 1);
+```
+*Effects:* Equivalent to `deallocate_bytes(p, n*sizeof(T), alignof(T))`.
+``` cpp
+template<class T, class CtorArgs...>
+  [[nodiscard]] T* new_object(CtorArgs&&... ctor_args);
+```
+*Effects:* Allocates and constructs an object of type `T`, as follows.
+Equivalent to:
+``` cpp
+T* p = allocate_object<T>();
+try {
+  construct(p, std::forward<CtorArgs>(ctor_args)...);
+} catch (...) {
+  deallocate_object(p);
+  throw;
+}
+return p;
+```
+[*Note 3*: `T` is not deduced and must therefore be provided as a
+template argument. — *end note*]
+``` cpp
+template<class T>
+  void delete_object(T* p);
+```
+*Effects:* Equivalent to:
+``` cpp
+destroy(p);
+deallocate_object(p);
+```
 ``` cpp
 template<class T, class... Args>
   void construct(T* p, Args&&... args);
 ```
+*Mandates:* Uses-allocator construction of `T` with allocator `*this`
+(see  [[allocator.uses.construction]]) and constructor arguments
+`std::forward<Args>(args)...` is well-formed.
 *Effects:* Construct a `T` object in the storage whose address is
+represented by `p` by uses-allocator construction with allocator `*this`
+and constructor arguments `std::forward<Args>(args)...`.
 *Throws:* Nothing unless the constructor for `T` throws.
 ``` cpp
 template<class T>
   void destroy(T* p);
 ```

Diff to HTML by rtfpessoa