[vector] - C++14 → C++17

Files changed (1) hide show

tmp/tmp723rqss9/{from.md → to.md} +101 -82

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

@@ -1,64 +1,62 @@
 ### Class template `vector` <a id="vector">[[vector]]</a>
 #### Class template `vector` overview <a id="vector.overview">[[vector.overview]]</a>
-A `vector` is a sequence container that supports random access
-iterators. In addition, it supports (amortized) constant time insert and
-erase operations at the end; insert and erase in the middle take linear
-time. Storage management is handled automatically, though hints can be
-given to improve efficiency. The elements of a vector are stored
-contiguously, meaning that if `v` is a `vector<T, Allocator>` where `T`
-is some type other than `bool`, then it obeys the identity
-`&v[n] == &v[0] + n` for all `0 <= n < v.size()`.
 A `vector` satisfies all of the requirements of a container and of a
 reversible container (given in two tables in
 [[container.requirements]]), of a sequence container, including most of
-the optional sequence container requirements ([[sequence.reqmts]]), and
-of an allocator-aware container (Table
-[[tab:containers.allocatoraware]]). The exceptions are the `push_front`,
-`pop_front`, and `emplace_front` member functions, which are not
-provided. Descriptions are provided here only for operations on `vector`
-that are not described in one of these tables or for operations where
-there is additional semantic information.
 ``` cpp
 namespace std {
   template <class T, class Allocator = allocator<T>>
   class vector {
   public:
     // types:
- typedef value_type&                           reference;
- typedef const value_type&                     const_reference;
- typedef implementation-defined iterator;       // see [container.requirements]
- typedef implementation-defined                const_iterator; // see [container.requirements]
- typedef implementation-defined                size_type;      // see [container.requirements]
- typedef implementation-defined                difference_type;// see [container.requirements]
- typedef T                                     value_type;
- typedef Allocator                             allocator_type;
- typedef typename allocator_traits<Allocator>::pointer           pointer;
- typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
- typedef std::reverse_iterator<iterator>       reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-    // [vector.cons], construct/copy/destroy:
-    vector() : vector(Allocator()) { }
-    explicit vector(const Allocator&);
     explicit vector(size_type n, const Allocator& = Allocator());
     vector(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
-      vector(InputIterator first, InputIterator last,
-             const Allocator& = Allocator());
     vector(const vector& x);
-    vector(vector&&);
     vector(const vector&, const Allocator&);
     vector(vector&&, const Allocator&);
     vector(initializer_list<T>, const Allocator& = Allocator());
     ~vector();
     vector& operator=(const vector& x);
-    vector& operator=(vector&& x);
     vector& operator=(initializer_list<T>);
     template <class InputIterator>
       void assign(InputIterator first, InputIterator last);
     void assign(size_type n, const T& u);
     void assign(initializer_list<T>);
@@ -77,17 +75,17 @@ namespace std {
     const_iterator         cbegin() const noexcept;
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
-    // [vector.capacity], capacity:
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     void      resize(size_type sz);
     void      resize(size_type sz, const T& c);
-    size_type capacity() const noexcept;
-    bool      empty() const noexcept;
     void      reserve(size_type n);
     void      shrink_to_fit();
     // element access:
     reference       operator[](size_type n);
@@ -101,30 +99,36 @@ namespace std {
     // [vector.data], data access
     T*       data() noexcept;
     const T* data() const noexcept;
-    // [vector.modifiers], modifiers:
-    template <class... Args> void emplace_back(Args&&... args);
     void push_back(const T& x);
     void push_back(T&& x);
     void pop_back();
     template <class... Args> iterator emplace(const_iterator position, Args&&... args);
     iterator insert(const_iterator position, const T& x);
     iterator insert(const_iterator position, T&& x);
     iterator insert(const_iterator position, size_type n, const T& x);
     template <class InputIterator>
- iterator insert(const_iterator position,
-                        InputIterator first, InputIterator last);
     iterator insert(const_iterator position, initializer_list<T> il);
     iterator erase(const_iterator position);
     iterator erase(const_iterator first, const_iterator last);
-    void     swap(vector&);
     void     clear() noexcept;
   };
   template <class T, class Allocator>
     bool operator==(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
@@ -134,16 +138,22 @@ namespace std {
   template <class T, class Allocator>
     bool operator>=(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
-  // [vector.special], specialized algorithms:
   template <class T, class Allocator>
-    void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
 }
 ```
 #### `vector` constructors, copy, and assignment <a id="vector.cons">[[vector.cons]]</a>
 ``` cpp
 explicit vector(const Allocator&);
 ```
@@ -184,13 +194,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.
 #### `vector` capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 size_type capacity() const noexcept;
@@ -229,20 +239,30 @@ vector greater than the value of `capacity()`.
 void shrink_to_fit();
 ```
 *Requires:* `T` shall be `MoveInsertable` into `*this`.
 *Complexity:* Linear in the size of the sequence.
-*Remarks:* `shrink_to_fit` is a non-binding request to reduce
-`capacity()` to `size()`. The request is non-binding to allow latitude
-for implementation-specific optimizations. If an exception is thrown
-other than by the move constructor of a non-`CopyInsertable` `T` there
-are no effects.
 ``` cpp
-void swap(vector& x);
 ```
 *Effects:* Exchanges the contents and `capacity()` of `*this` with that
 of `x`.
@@ -250,13 +270,13 @@ of `x`.
 ``` cpp
 void resize(size_type sz);
 ```
-*Effects:* If `sz <= size()`, equivalent to calling `pop_back()`
-`size() - sz` times. If `size() < sz`, appends `sz - size()`
-default-inserted elements to the sequence.
 *Requires:* `T` shall be `MoveInsertable` and `DefaultInsertable` into
 `*this`.
 *Remarks:* If an exception is thrown other than by the move constructor
@@ -264,13 +284,13 @@ of a non-`CopyInsertable` `T` there are no effects.
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
-*Effects:* If `sz <= size()`, equivalent to calling `pop_back()`
-`size() - sz` times. If `size() < sz`, appends `sz - size()` copies of
-`c` to the sequence.
 *Requires:* `T` shall be `CopyInsertable` into `*this`.
 *Remarks:* If an exception is thrown there are no effects.
@@ -280,11 +300,11 @@ void resize(size_type sz, const T& c);
 T*         data() noexcept;
 const T*   data() const noexcept;
 ```
 *Returns:* A pointer such that \[`data()`, `data() + size()`) is a valid
-range. For a non-empty vector, `data()` `==` `&front()`.
 *Complexity:* Constant time.
 #### `vector` modifiers <a id="vector.modifiers">[[vector.modifiers]]</a>
@@ -294,55 +314,54 @@ iterator insert(const_iterator position, T&& x);
 iterator insert(const_iterator position, size_type n, const T& x);
 template <class InputIterator>
   iterator insert(const_iterator position, InputIterator first, InputIterator last);
 iterator insert(const_iterator position, initializer_list<T>);
-template <class... Args> void emplace_back(Args&&... args);
 template <class... Args> iterator emplace(const_iterator position, Args&&... args);
 void push_back(const T& x);
 void push_back(T&& x);
 ```
 *Remarks:* Causes reallocation if the new size is greater than the old
-capacity. If no reallocation happens, all the iterators and references
-before the insertion point remain valid. 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 `CopyInsertable` or
-`is_nothrow_move_constructible<T>::value` is `true`, there are no
-effects. Otherwise, if an exception is thrown by the move constructor of
-a non-`CopyInsertable` `T`, the effects are unspecified.
 *Complexity:* The complexity is linear in the number of elements
 inserted plus the distance to the end of the vector.
 ``` cpp
 iterator erase(const_iterator position);
 iterator erase(const_iterator first, const_iterator last);
 ```
 *Effects:* Invalidates iterators and references at or after the point of
 the erase.
 *Complexity:* The destructor of `T` is called the number of times equal
-to the number of the elements erased, but the move assignment operator
-of `T` is called the number of times equal to the number of elements in
-the vector after the erased elements.
-*Throws:* Nothing unless an exception is thrown by the copy constructor,
-move constructor, assignment operator, or move assignment operator of
-`T`.
 #### `vector` specialized algorithms <a id="vector.special">[[vector.special]]</a>
 ``` cpp
 template <class T, class Allocator>
-  void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
 ```
-*Effects:*
-``` cpp
-x.swap(y);
-```

 ### Class template `vector` <a id="vector">[[vector]]</a>
 #### Class template `vector` overview <a id="vector.overview">[[vector.overview]]</a>
+A `vector` is a sequence container that supports (amortized) constant
+time insert and erase operations at the end; insert and erase in the
+middle take linear time. Storage management is handled automatically,
+though hints can be given to improve efficiency.
 A `vector` satisfies all of the requirements of a container and of a
 reversible container (given in two tables in
 [[container.requirements]]), of a sequence container, including most of
+the optional sequence container requirements ([[sequence.reqmts]]), of
+an allocator-aware container (Table  [[tab:containers.allocatoraware]]),
+and, for an element type other than `bool`, of a contiguous container (
+[[container.requirements.general]]). The exceptions are the
+`push_front`, `pop_front`, and `emplace_front` member functions, which
+are not provided. Descriptions are provided here only for operations on
+`vector` that are not described in one of these tables or for operations
+where there is additional semantic information.
 ``` cpp
 namespace std {
   template <class T, class Allocator = allocator<T>>
   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; // see [container.requirements]
+ using difference_type        = implementation-defined; // see [container.requirements]
+ using iterator               = implementation-defined  // type of vector::iterator; // see [container.requirements]
+ using const_iterator         = implementation-defined  // type of vector::const_iterator; // see [container.requirements]
+ using reverse_iterator       = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    // [vector.cons], construct/copy/destroy
+    vector() noexcept(noexcept(Allocator())) : vector(Allocator()) { }
+    explicit vector(const Allocator&) noexcept;
     explicit vector(size_type n, const Allocator& = Allocator());
     vector(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
+      vector(InputIterator first, InputIterator last, const Allocator& = Allocator());
     vector(const vector& x);
+    vector(vector&&) noexcept;
     vector(const vector&, const Allocator&);
     vector(vector&&, const Allocator&);
     vector(initializer_list<T>, const Allocator& = Allocator());
     ~vector();
     vector& operator=(const vector& x);
+    vector& operator=(vector&& x)
+      noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+               allocator_traits<Allocator>::is_always_equal::value);
     vector& operator=(initializer_list<T>);
     template <class InputIterator>
       void assign(InputIterator first, InputIterator last);
     void assign(size_type n, const T& u);
     void assign(initializer_list<T>);
     const_iterator         cbegin() const noexcept;
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
+    // [vector.capacity], capacity
+    bool      empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
+    size_type capacity() const noexcept;
     void      resize(size_type sz);
     void      resize(size_type sz, const T& c);
     void      reserve(size_type n);
     void      shrink_to_fit();
     // element access:
     reference       operator[](size_type n);
     // [vector.data], data access
     T*       data() noexcept;
     const T* data() const noexcept;
+    // [vector.modifiers], modifiers
+    template <class... Args> reference emplace_back(Args&&... args);
     void push_back(const T& x);
     void push_back(T&& x);
     void pop_back();
     template <class... Args> iterator emplace(const_iterator position, Args&&... args);
     iterator insert(const_iterator position, const T& x);
     iterator insert(const_iterator position, T&& x);
     iterator insert(const_iterator position, size_type n, const T& x);
     template <class InputIterator>
+ iterator insert(const_iterator position, InputIterator first, InputIterator last);
     iterator insert(const_iterator position, initializer_list<T> il);
     iterator erase(const_iterator position);
     iterator erase(const_iterator first, const_iterator last);
+    void     swap(vector&)
+      noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+               allocator_traits<Allocator>::is_always_equal::value);
     void     clear() noexcept;
   };
+  template<class InputIterator,
+           class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
+    vector(InputIterator, InputIterator, Allocator = Allocator())
+      -> vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
   template <class T, class Allocator>
     bool operator==(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
   template <class T, class Allocator>
     bool operator>=(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
+  // [vector.special], specialized algorithms
   template <class T, class Allocator>
+    void swap(vector<T, Allocator>& x, vector<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
 }
 ```
+An incomplete type `T` may be used when instantiating `vector` if the
+allocator satisfies the allocator completeness requirements (
+[[allocator.requirements.completeness]]). `T` shall be complete before
+any member of the resulting specialization of `vector` is referenced.
 #### `vector` constructors, copy, and assignment <a id="vector.cons">[[vector.cons]]</a>
 ``` cpp
 explicit vector(const Allocator&);
 ```
 *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.
 #### `vector` capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 size_type capacity() const noexcept;
 void shrink_to_fit();
 ```
 *Requires:* `T` shall be `MoveInsertable` into `*this`.
+*Effects:* `shrink_to_fit` is a non-binding request to reduce
+`capacity()` to `size()`.
+[*Note 1*: 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-`CopyInsertable` `T` there are no effects.
 *Complexity:* Linear 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. If no reallocation happens, they remain valid.
 ``` cpp
+void swap(vector& x)
+  noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+           allocator_traits<Allocator>::is_always_equal::value);
 ```
 *Effects:* Exchanges the contents and `capacity()` of `*this` with that
 of `x`.
 ``` cpp
 void resize(size_type sz);
 ```
+*Effects:* If `sz < size()`, erases the last `size() - sz` elements from
+the sequence. Otherwise, appends `sz - size()` default-inserted elements
+to the sequence.
 *Requires:* `T` shall be `MoveInsertable` and `DefaultInsertable` into
 `*this`.
 *Remarks:* If an exception is thrown other than by the move constructor
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
+*Effects:* If `sz < size()`, erases the last `size() - sz` elements from
+the sequence. Otherwise, appends `sz - size()` copies of `c` to the
+sequence.
 *Requires:* `T` shall be `CopyInsertable` into `*this`.
 *Remarks:* If an exception is thrown there are no effects.
 T*         data() noexcept;
 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.
 #### `vector` modifiers <a id="vector.modifiers">[[vector.modifiers]]</a>
 iterator insert(const_iterator position, size_type n, const T& x);
 template <class InputIterator>
   iterator insert(const_iterator position, InputIterator first, InputIterator last);
 iterator insert(const_iterator position, initializer_list<T>);
+template <class... Args> reference emplace_back(Args&&... args);
 template <class... Args> iterator emplace(const_iterator position, Args&&... args);
 void push_back(const T& x);
 void push_back(T&& x);
 ```
 *Remarks:* Causes reallocation if the new size is greater than the old
+capacity. Reallocation invalidates all the references, pointers, and
+iterators referring to the elements in the sequence. If no reallocation
+happens, all the iterators and references before the insertion point
+remain valid. 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 `CopyInsertable` 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-`CopyInsertable` `T`, the effects are unspecified.
 *Complexity:* The complexity is linear in the number of elements
 inserted plus the distance to the end of the vector.
 ``` cpp
 iterator erase(const_iterator position);
 iterator erase(const_iterator first, const_iterator last);
+void pop_back();
 ```
 *Effects:* Invalidates iterators and references at or after the point of
 the erase.
 *Complexity:* The destructor of `T` is called the number of times equal
+to the number of the elements erased, but the assignment operator of `T`
+is called the number of times equal to the number of elements in the
+vector after the erased elements.
+*Throws:* Nothing unless an exception is thrown by the assignment
+operator or move assignment operator of `T`.
 #### `vector` specialized algorithms <a id="vector.special">[[vector.special]]</a>
 ``` cpp
 template <class T, class Allocator>
+  void swap(vector<T, Allocator>& x, vector<T, Allocator>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* As if by `x.swap(y)`.

Diff to HTML by rtfpessoa