[mem.res] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpz80e0ywa/{from.md → to.md} +32 -22

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

@@ -47,11 +47,11 @@ namespace std::pmr {
     memory_resource(const memory_resource&) = default;
     virtual ~memory_resource();
     memory_resource& operator=(const memory_resource&) = default;
- [[nodiscard]] void* allocate(size_t bytes, size_t alignment = max_align);
     void deallocate(void* p, size_t bytes, size_t alignment = max_align);
     bool is_equal(const memory_resource& other) const noexcept;
   private:
@@ -70,11 +70,11 @@ namespace std::pmr {
 ```
 *Effects:* Destroys this `memory_resource`.
 ``` cpp
-[[nodiscard]] void* allocate(size_t bytes, size_t alignment = max_align);
 ```
 *Effects:* Allocates storage by calling `do_allocate(bytes, alignment)`
 and implicitly creates objects within the allocated region of storage.
@@ -127,16 +127,16 @@ allocated storage.
 ``` cpp
 virtual bool do_is_equal(const memory_resource& other) const noexcept = 0;
 ```
 *Returns:* A derived class shall implement this function to return
-`true` if memory allocated from `this` can be deallocated from `other`
 and vice-versa, otherwise `false`.
 [*Note 1*: It is possible that the most-derived type of `other` does
-not match the type of `this`. For a derived class `D`, an implementation
-of this function can immediately return `false` if
 `dynamic_cast<const D*>(&other) == nullptr`. — *end note*]
 #### Equality <a id="mem.res.eq">[[mem.res.eq]]</a>
 ``` cpp
@@ -182,23 +182,26 @@ namespace std::pmr {
       polymorphic_allocator(const polymorphic_allocator<U>& other) noexcept;
     polymorphic_allocator& operator=(const polymorphic_allocator&) = delete;
     // [mem.poly.allocator.mem], member functions
- [[nodiscard]] Tp* allocate(size_t n);
     void deallocate(Tp* p, size_t n);
- [[nodiscard]] void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));
     void deallocate_bytes(void* p, size_t nbytes, size_t alignment = alignof(max_align_t));
-    template<class T> [[nodiscard]] T* allocate_object(size_t n = 1);
     template<class T> void deallocate_object(T* p, size_t n = 1);
-    template<class T, class... CtorArgs> [[nodiscard]] T* new_object(CtorArgs&&... ctor_args);
     template<class T> void delete_object(T* p);
     template<class T, class... Args>
       void construct(T* p, Args&&... args);
     polymorphic_allocator select_on_container_copy_construction() const;
     memory_resource* resource() const;
     // friends
@@ -238,11 +241,11 @@ template<class U> polymorphic_allocator(const polymorphic_allocator<U>& other) n
 *Effects:* Sets `memory_rsrc` to `other.resource()`.
 #### 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:
@@ -261,11 +264,11 @@ void deallocate(Tp* p, size_t n);
 `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);`
@@ -281,11 +284,11 @@ void deallocate_bytes(void* p, size_t nbytes, size_t alignment = alignof(max_ali
 *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:
@@ -306,11 +309,11 @@ template<class T>
 *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:
@@ -334,11 +337,11 @@ template<class T>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-allocator_traits<polymorphic_allocator>::destroy(*this, p);
 deallocate_object(p);
 ```
 ``` cpp
 template<class T, class... Args>
@@ -347,16 +350,23 @@ template<class T, class... 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
 polymorphic_allocator select_on_container_copy_construction() const;
 ```
 *Returns:* `polymorphic_allocator()`.
@@ -415,13 +425,13 @@ resource pointer to `r`, otherwise sets the default memory resource
 pointer to `new_delete_resource()`.
 *Returns:* The previous value of the default memory resource pointer.
 *Remarks:* Calling the `set_default_resource` and `get_default_resource`
-functions shall not incur a data race. A call to the
-`set_default_resource` function shall synchronize with subsequent calls
-to the `set_default_resource` and `get_default_resource` functions.
 ``` cpp
 memory_resource* get_default_resource() noexcept;
 ```
@@ -538,11 +548,11 @@ size_t max_blocks_per_chunk;
 The maximum number of blocks that will be allocated at once from the
 upstream memory resource [[mem.res.monotonic.buffer]] to replenish a
 pool. If the value of `max_blocks_per_chunk` is zero or is greater than
 an *implementation-defined* limit, that limit is used instead. The
 implementation may choose to use a smaller value than is specified in
-this field and may use different values for different pools.
 ``` cpp
 size_t largest_required_pool_block;
 ```
@@ -550,11 +560,11 @@ The largest allocation size that is required to be fulfilled using the
 pooling mechanism. Attempts to allocate a single block larger than this
 threshold will be allocated directly from the upstream memory resource.
 If `largest_required_pool_block` is zero or is greater than an
 *implementation-defined* limit, that limit is used instead. The
 implementation may choose a pass-through threshold larger than specified
-in this field.
 #### Constructors and destructors <a id="mem.res.pool.ctor">[[mem.res.pool.ctor]]</a>
 ``` cpp
 synchronized_pool_resource(const pool_options& opts, memory_resource* upstream);
@@ -739,12 +749,12 @@ void release();
 *Effects:* Calls `upstream_rsrc->deallocate()` as necessary to release
 all allocated memory. Resets `current_buffer` and `next_buffer_size` to
 their initial values at construction.
 [*Note 1*: The memory is released back to `upstream_rsrc` even if some
-blocks that were allocated from `this` have not been deallocated from
-`this`. — *end note*]
 ``` cpp
 memory_resource* upstream_resource() const;
 ```

     memory_resource(const memory_resource&) = default;
     virtual ~memory_resource();
     memory_resource& operator=(const memory_resource&) = default;
+    void* allocate(size_t bytes, size_t alignment = max_align);
     void deallocate(void* p, size_t bytes, size_t alignment = max_align);
     bool is_equal(const memory_resource& other) const noexcept;
   private:
 ```
 *Effects:* Destroys this `memory_resource`.
 ``` cpp
+void* allocate(size_t bytes, size_t alignment = max_align);
 ```
 *Effects:* Allocates storage by calling `do_allocate(bytes, alignment)`
 and implicitly creates objects within the allocated region of storage.
 ``` cpp
 virtual bool do_is_equal(const memory_resource& other) const noexcept = 0;
 ```
 *Returns:* A derived class shall implement this function to return
+`true` if memory allocated from `*this` can be deallocated from `other`
 and vice-versa, otherwise `false`.
 [*Note 1*: It is possible that the most-derived type of `other` does
+not match the type of `*this`. For a derived class `D`, an
+implementation of this function can immediately return `false` if
 `dynamic_cast<const D*>(&other) == nullptr`. — *end note*]
 #### Equality <a id="mem.res.eq">[[mem.res.eq]]</a>
 ``` cpp
       polymorphic_allocator(const polymorphic_allocator<U>& other) noexcept;
     polymorphic_allocator& operator=(const polymorphic_allocator&) = delete;
     // [mem.poly.allocator.mem], member functions
+    Tp* allocate(size_t n);
     void deallocate(Tp* p, size_t n);
+    void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));
     void deallocate_bytes(void* p, size_t nbytes, size_t alignment = alignof(max_align_t));
+    template<class T> T* allocate_object(size_t n = 1);
     template<class T> void deallocate_object(T* p, size_t n = 1);
+    template<class T, class... CtorArgs> T* new_object(CtorArgs&&... ctor_args);
     template<class T> void delete_object(T* p);
     template<class T, class... Args>
       void construct(T* p, Args&&... args);
+    template<class T>
+      void destroy(T* p);
     polymorphic_allocator select_on_container_copy_construction() const;
     memory_resource* resource() const;
     // friends
 *Effects:* Sets `memory_rsrc` to `other.resource()`.
 #### Member functions <a id="mem.poly.allocator.mem">[[mem.poly.allocator.mem]]</a>
 ``` cpp
+Tp* allocate(size_t n);
 ```
 *Effects:* If `numeric_limits<size_t>::max() / sizeof(Tp) < n`, throws
 `bad_array_new_length`. Otherwise equivalent to:
 `memory_rsrc->deallocate(p, n * sizeof(Tp), alignof(Tp))`.
 *Throws:* Nothing.
 ``` cpp
+void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));
 ```
 *Effects:* Equivalent to:
 `return memory_rsrc->allocate(nbytes, alignment);`
 *Effects:* Equivalent to
 `memory_rsrc->deallocate(p, nbytes, alignment)`.
 ``` cpp
 template<class T>
+  T* allocate_object(size_t n = 1);
 ```
 *Effects:* Allocates memory suitable for holding an array of `n` objects
 of type `T`, as follows:
 *Effects:* Equivalent to `deallocate_bytes(p, n*sizeof(T), alignof(T))`.
 ``` cpp
 template<class T, class... CtorArgs>
+  T* new_object(CtorArgs&&... ctor_args);
 ```
 *Effects:* Allocates and constructs an object of type `T`, as follows.
 Equivalent to:
 ```
 *Effects:* Equivalent to:
 ``` cpp
+destroy(p);
 deallocate_object(p);
 ```
 ``` cpp
 template<class T, class... 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:* Constructs 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);
+```
+*Effects:* Equivalent to `p->T̃()`.
 ``` cpp
 polymorphic_allocator select_on_container_copy_construction() const;
 ```
 *Returns:* `polymorphic_allocator()`.
 pointer to `new_delete_resource()`.
 *Returns:* The previous value of the default memory resource pointer.
 *Remarks:* Calling the `set_default_resource` and `get_default_resource`
+functions shall not incur a data race [[intro.races]]. A call to the
+`set_default_resource` function synchronizes with subsequent calls to
+the `set_default_resource` and `get_default_resource` functions.
 ``` cpp
 memory_resource* get_default_resource() noexcept;
 ```
 The maximum number of blocks that will be allocated at once from the
 upstream memory resource [[mem.res.monotonic.buffer]] to replenish a
 pool. If the value of `max_blocks_per_chunk` is zero or is greater than
 an *implementation-defined* limit, that limit is used instead. The
 implementation may choose to use a smaller value than is specified in
+this member and may use different values for different pools.
 ``` cpp
 size_t largest_required_pool_block;
 ```
 pooling mechanism. Attempts to allocate a single block larger than this
 threshold will be allocated directly from the upstream memory resource.
 If `largest_required_pool_block` is zero or is greater than an
 *implementation-defined* limit, that limit is used instead. The
 implementation may choose a pass-through threshold larger than specified
+in this member.
 #### Constructors and destructors <a id="mem.res.pool.ctor">[[mem.res.pool.ctor]]</a>
 ``` cpp
 synchronized_pool_resource(const pool_options& opts, memory_resource* upstream);
 *Effects:* Calls `upstream_rsrc->deallocate()` as necessary to release
 all allocated memory. Resets `current_buffer` and `next_buffer_size` to
 their initial values at construction.
 [*Note 1*: The memory is released back to `upstream_rsrc` even if some
+blocks that were allocated from `*this` have not been deallocated from
+`*this`. — *end note*]
 ``` cpp
 memory_resource* upstream_resource() const;
 ```

Diff to HTML by rtfpessoa