[vector] - C++23 → Trunk

Files changed (1) hide show

tmp/tmphpwjezv3/{from.md → to.md} +48 -30

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

@@ -28,12 +28,12 @@ namespace std {
   class vector {
   public:
     // types
     using value_type             = T;
     using allocator_type         = Allocator;
-    using pointer                = typename allocator_traits<Allocator>::pointer;
-    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of vector::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of vector::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of vector::iterator; // see [container.requirements]
@@ -83,11 +83,11 @@ namespace std {
     constexpr const_iterator         cend() const noexcept;
     constexpr const_reverse_iterator crbegin() const noexcept;
     constexpr const_reverse_iterator crend() const noexcept;
     // [vector.capacity], capacity
- [[nodiscard]] constexpr bool empty() const noexcept;
     constexpr size_type size() const noexcept;
     constexpr size_type max_size() const noexcept;
     constexpr size_type capacity() const noexcept;
     constexpr void      resize(size_type sz);
     constexpr void      resize(size_type sz, const T& c);
@@ -95,12 +95,12 @@ namespace std {
     constexpr void      shrink_to_fit();
     // element access
     constexpr reference       operator[](size_type n);
     constexpr const_reference operator[](size_type n) const;
-    constexpr const_reference at(size_type n) const;
     constexpr reference       at(size_type n);
     constexpr reference       front();
     constexpr const_reference front() const;
     constexpr reference       back();
     constexpr const_reference back() const;
@@ -161,11 +161,11 @@ constexpr explicit vector(const Allocator&) noexcept;
 ``` cpp
 constexpr explicit vector(size_type n, const Allocator& = Allocator());
 ```
-*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Effects:* Constructs a `vector` with `n` default-inserted elements
 using the specified allocator.
 *Complexity:* Linear in `n`.
@@ -173,11 +173,11 @@ using the specified allocator.
 ``` cpp
 constexpr vector(size_type n, const T& value,
                  const Allocator& = Allocator());
 ```
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* Constructs a `vector` with `n` copies of `value`, using the
 specified allocator.
 *Complexity:* Linear in `n`.
@@ -191,13 +191,13 @@ template<class InputIterator>
 *Effects:* Constructs a `vector` equal to the range \[`first`, `last`),
 using the specified allocator.
 *Complexity:* Makes only N calls to the copy constructor of `T` (where N
 is the distance between `first` and `last`) and no reallocations if
-iterators `first` and `last` are of forward, bidirectional, or random
-access categories. It makes order N calls to the copy constructor of `T`
-and order log N reallocations if they are just input iterators.
 ``` cpp
 template<container-compatible-range<T> R>
   constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator());
 ```
@@ -205,14 +205,21 @@ template<container-compatible-range<T> R>
 *Effects:* Constructs a `vector` object with the elements of the range
 `rg`, using the specified allocator.
 *Complexity:* Initializes exactly N elements from the results of
 dereferencing successive iterators of `rg`, where N is
-`ranges::distance(rg)`. Performs no reallocations if `R` models
-`ranges::forward_range` or `ranges::sized_range`; otherwise, performs
-order log N reallocations and order N calls to the copy or move
-constructor of `T`.
 #### Capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 constexpr size_type capacity() const noexcept;
@@ -225,11 +232,11 @@ requiring reallocation.
 ``` cpp
 constexpr void reserve(size_type n);
 ```
-*Preconditions:* `T` is *Cpp17MoveInsertable* into `*this`.
 *Effects:* A directive that informs a `vector` of a planned change in
 size, so that it can manage the storage allocation accordingly. After
 `reserve()`, `capacity()` is greater or equal to the argument of
 `reserve` if reallocation happens; and equal to the previous value of
@@ -238,16 +245,15 @@ if the current capacity is less than the argument of `reserve()`. If an
 exception is thrown other than by the move constructor of a
 non-*Cpp17CopyInsertable* type, there are no effects.
 *Throws:* `length_error` if `n > max_size()`.[^4]
-*Complexity:* It does not change the size of the sequence and takes at
-most linear time in the size of the sequence.
-*Remarks:* Reallocation invalidates all the references, pointers, and
-iterators referring to the elements in the sequence, as well as the
-past-the-end iterator.
 [*Note 1*: If no reallocation happens, they remain
 valid. — *end note*]
 No reallocation shall take place during insertions that happen after a
@@ -256,21 +262,21 @@ greater than the value of `capacity()`.
 ``` cpp
 constexpr void shrink_to_fit();
 ```
-*Preconditions:* `T` is *Cpp17MoveInsertable* into `*this`.
 *Effects:* `shrink_to_fit` is a non-binding request to reduce
 `capacity()` to `size()`.
 [*Note 2*: The request is non-binding to allow latitude for
 implementation-specific optimizations. — *end note*]
 It does not increase `capacity()`, but may reduce `capacity()` by
 causing reallocation. If an exception is thrown other than by the move
-constructor of a non-*Cpp17CopyInsertable* `T` there are no effects.
 *Complexity:* If reallocation happens, linear in the size of the
 sequence.
 *Remarks:* Reallocation invalidates all the references, pointers, and
@@ -294,40 +300,40 @@ of `x`.
 ``` cpp
 constexpr void resize(size_type sz);
 ```
 *Preconditions:* `T` is *Cpp17MoveInsertable* and
-*Cpp17DefaultInsertable* into `*this`.
 *Effects:* If `sz < size()`, erases the last `size() - sz` elements from
 the sequence. Otherwise, appends `sz - size()` default-inserted elements
 to the sequence.
 *Remarks:* If an exception is thrown other than by the move constructor
-of a non-*Cpp17CopyInsertable* `T` there are no effects.
 ``` cpp
 constexpr void resize(size_type sz, const T& c);
 ```
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* If `sz < size()`, erases the last `size() - sz` elements from
 the sequence. Otherwise, appends `sz - size()` copies of `c` to the
 sequence.
-*Remarks:* If an exception is thrown there are no effects.
 #### Data <a id="vector.data">[[vector.data]]</a>
 ``` cpp
 constexpr T*       data() noexcept;
 constexpr const T* data() const noexcept;
 ```
 *Returns:* A pointer such that \[`data()`, `data() + size()`) is a valid
-range. For a non-empty vector, `data()` `==` `addressof(front())`.
 *Complexity:* Constant time.
 #### Modifiers <a id="vector.modifiers">[[vector.modifiers]]</a>
@@ -359,17 +365,29 @@ iterators referring to the elements in the sequence, as well as the
 past-the-end iterator. If no reallocation happens, then references,
 pointers, and iterators before the insertion point remain valid but
 those at or after the insertion point, including the past-the-end
 iterator, are invalidated. If an exception is thrown other than by the
 copy constructor, move constructor, assignment operator, or move
-assignment operator of `T` or by any `InputIterator` operation there are
-no effects. If an exception is thrown while inserting a single element
-at the end and `T` is *Cpp17CopyInsertable* or
 `is_nothrow_move_constructible_v<T>` is `true`, there are no effects.
 Otherwise, if an exception is thrown by the move constructor of a
 non-*Cpp17CopyInsertable* `T`, the effects are unspecified.
 ``` cpp
 constexpr iterator erase(const_iterator position);
 constexpr iterator erase(const_iterator first, const_iterator last);
 constexpr void pop_back();
 ```
@@ -386,11 +404,11 @@ is called the number of times equal to the number of elements in the
 vector after the erased elements.
 #### Erasure <a id="vector.erasure">[[vector.erasure]]</a>
 ``` cpp
-template<class T, class Allocator, class U>
   constexpr typename vector<T, Allocator>::size_type
     erase(vector<T, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:

   class vector {
   public:
     // types
     using value_type             = T;
     using allocator_type         = Allocator;
+    using pointer                = allocator_traits<Allocator>::pointer;
+    using const_pointer          = allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of vector::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of vector::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of vector::iterator; // see [container.requirements]
     constexpr const_iterator         cend() const noexcept;
     constexpr const_reverse_iterator crbegin() const noexcept;
     constexpr const_reverse_iterator crend() const noexcept;
     // [vector.capacity], capacity
+    constexpr bool empty() const noexcept;
     constexpr size_type size() const noexcept;
     constexpr size_type max_size() const noexcept;
     constexpr size_type capacity() const noexcept;
     constexpr void      resize(size_type sz);
     constexpr void      resize(size_type sz, const T& c);
     constexpr void      shrink_to_fit();
     // element access
     constexpr reference       operator[](size_type n);
     constexpr const_reference operator[](size_type n) const;
     constexpr reference       at(size_type n);
+    constexpr const_reference at(size_type n) const;
     constexpr reference       front();
     constexpr const_reference front() const;
     constexpr reference       back();
     constexpr const_reference back() const;
 ``` cpp
 constexpr explicit vector(size_type n, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `vector`.
 *Effects:* Constructs a `vector` with `n` default-inserted elements
 using the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 constexpr vector(size_type n, const T& value,
                  const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `vector`.
 *Effects:* Constructs a `vector` with `n` copies of `value`, using the
 specified allocator.
 *Complexity:* Linear in `n`.
 *Effects:* Constructs a `vector` equal to the range \[`first`, `last`),
 using the specified allocator.
 *Complexity:* Makes only N calls to the copy constructor of `T` (where N
 is the distance between `first` and `last`) and no reallocations if
+`InputIterator` meets the *Cpp17ForwardIterator* requirements. It makes
+order N calls to the copy constructor of `T` and order log N
+reallocations if they are just input iterators.
 ``` cpp
 template<container-compatible-range<T> R>
   constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `vector` object with the elements of the range
 `rg`, using the specified allocator.
 *Complexity:* Initializes exactly N elements from the results of
 dereferencing successive iterators of `rg`, where N is
+`ranges::distance(rg)`.
+Performs no reallocations if:
+- `R` models `ranges::approximately_sized_range`, and
+  `ranges::distance(rg) <= ranges::reserve_hint(rg)` is `true`, or
+- `R` models `ranges::forward_range` and `R` does not model
+  `ranges::approximately_sized_range`.
+Otherwise, performs order log N reallocations and order N calls to the
+copy or move constructor of `T`.
 #### Capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 constexpr size_type capacity() const noexcept;
 ``` cpp
 constexpr void reserve(size_type n);
 ```
+*Preconditions:* `T` is *Cpp17MoveInsertable* into `vector`.
 *Effects:* A directive that informs a `vector` of a planned change in
 size, so that it can manage the storage allocation accordingly. After
 `reserve()`, `capacity()` is greater or equal to the argument of
 `reserve` if reallocation happens; and equal to the previous value of
 exception is thrown other than by the move constructor of a
 non-*Cpp17CopyInsertable* type, there are no effects.
 *Throws:* `length_error` if `n > max_size()`.[^4]
+*Complexity:* Linear in the size of the sequence.
+*Remarks:* The size of the sequence is not changed. Reallocation
+invalidates all the references, pointers, and iterators referring to the
+elements in the sequence, as well as the past-the-end iterator.
 [*Note 1*: If no reallocation happens, they remain
 valid. — *end note*]
 No reallocation shall take place during insertions that happen after a
 ``` cpp
 constexpr void shrink_to_fit();
 ```
+*Preconditions:* `T` is *Cpp17MoveInsertable* into `vector`.
 *Effects:* `shrink_to_fit` is a non-binding request to reduce
 `capacity()` to `size()`.
 [*Note 2*: The request is non-binding to allow latitude for
 implementation-specific optimizations. — *end note*]
 It does not increase `capacity()`, but may reduce `capacity()` by
 causing reallocation. If an exception is thrown other than by the move
+constructor of a non-*Cpp17CopyInsertable* `T`, there are no effects.
 *Complexity:* If reallocation happens, linear in the size of the
 sequence.
 *Remarks:* Reallocation invalidates all the references, pointers, and
 ``` cpp
 constexpr void resize(size_type sz);
 ```
 *Preconditions:* `T` is *Cpp17MoveInsertable* and
+*Cpp17DefaultInsertable* into `vector`.
 *Effects:* If `sz < size()`, erases the last `size() - sz` elements from
 the sequence. Otherwise, appends `sz - size()` default-inserted elements
 to the sequence.
 *Remarks:* If an exception is thrown other than by the move constructor
+of a non-*Cpp17CopyInsertable* `T`, there are no effects.
 ``` cpp
 constexpr void resize(size_type sz, const T& c);
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `vector`.
 *Effects:* If `sz < size()`, erases the last `size() - sz` elements from
 the sequence. Otherwise, appends `sz - size()` copies of `c` to the
 sequence.
+*Remarks:* If an exception is thrown, there are no effects.
 #### Data <a id="vector.data">[[vector.data]]</a>
 ``` cpp
 constexpr T*       data() noexcept;
 constexpr const T* data() const noexcept;
 ```
 *Returns:* A pointer such that \[`data()`, `data() + size()`) is a valid
+range. For a non-empty vector, `data() == addressof(front())` is `true`.
 *Complexity:* Constant time.
 #### Modifiers <a id="vector.modifiers">[[vector.modifiers]]</a>
 past-the-end iterator. If no reallocation happens, then references,
 pointers, and iterators before the insertion point remain valid but
 those at or after the insertion point, including the past-the-end
 iterator, are invalidated. If an exception is thrown other than by the
 copy constructor, move constructor, assignment operator, or move
+assignment operator of `T` or by any `InputIterator` operation, there
+are no effects. If an exception is thrown while inserting a single
+element at the end and `T` is *Cpp17CopyInsertable* or
 `is_nothrow_move_constructible_v<T>` is `true`, there are no effects.
 Otherwise, if an exception is thrown by the move constructor of a
 non-*Cpp17CopyInsertable* `T`, the effects are unspecified.
+For the declarations taking a range `R`, performs at most one
+reallocation if:
+- `R` models `ranges::approximately_sized_range` and
+  `ranges::distance(rg) <= ranges::reserve_hint(rg)` is `true`, or
+- `R` models `ranges::forward_range` and `R` does not model
+  `ranges::approximately_sized_range`.
+For the declarations taking a pair of `InputIterator`, performs at most
+one reallocation if `InputIterator` meets the *Cpp17ForwardIterator*
+requirements.
 ``` cpp
 constexpr iterator erase(const_iterator position);
 constexpr iterator erase(const_iterator first, const_iterator last);
 constexpr void pop_back();
 ```
 vector after the erased elements.
 #### Erasure <a id="vector.erasure">[[vector.erasure]]</a>
 ``` cpp
+template<class T, class Allocator, class U = T>
   constexpr typename vector<T, Allocator>::size_type
     erase(vector<T, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:

Diff to HTML by rtfpessoa