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

Files changed (1) hide show

tmp/tmpznmk2nzj/{from.md → to.md} +184 -158

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

@@ -1,32 +1,35 @@
 ### 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&;
@@ -37,159 +40,146 @@ namespace std {
     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>);
-    allocator_type get_allocator() const noexcept;
-    // iterators:
-    iterator               begin() noexcept;
-    const_iterator         begin() const noexcept;
-    iterator               end() noexcept;
-    const_iterator         end() const noexcept;
-    reverse_iterator       rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator       rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-    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);
-    const_reference operator[](size_type n) const;
-    const_reference at(size_type n) const;
-    reference       at(size_type n);
-    reference       front();
-    const_reference front() const;
-    reference       back();
-    const_reference back() const;
     // [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>
-    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>
-    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 an empty `vector`, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
-explicit vector(size_type n, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `vector` with `n` default-inserted elements
 using the specified allocator.
-*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
-vector(size_type n, const T& value,
                  const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `vector` with `n` copies of `value`, using the
 specified allocator.
-*Requires:* `T` shall be `CopyInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
-  vector(InputIterator first, InputIterator last,
                    const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `vector` equal to the range \[`first`, `last`),
 using the specified allocator.
@@ -198,152 +188,166 @@ using the specified allocator.
 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;
 ```
 *Returns:* The total number of elements that the vector can hold without
 requiring reallocation.
 ``` cpp
-void reserve(size_type n);
 ```
-*Requires:* `T` shall be `MoveInsertable` 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
 `capacity()` otherwise. Reallocation happens at this point if and only
 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-`CopyInsertable` type, there are no effects.
 *Complexity:* It does not change the size of the sequence and takes at
 most linear time in the size of the sequence.
 *Throws:* `length_error` if `n > max_size()`.[^4]
 *Remarks:* Reallocation invalidates all the references, pointers, and
-iterators referring to the elements in the sequence. No reallocation
-shall take place during insertions that happen after a call to
-`reserve()` until the time when an insertion would make the size of the
-vector greater than the value of `capacity()`.
 ``` cpp
-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`.
 *Complexity:* Constant time.
 ``` 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
-of a non-`CopyInsertable` `T` there are no effects.
 ``` 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.
-#### `vector` data <a id="vector.data">[[vector.data]]</a>
 ``` cpp
-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>
 ``` cpp
-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>);
-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.
@@ -353,15 +357,37 @@ 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)`.

 ### Class template `vector` <a id="vector">[[vector]]</a>
+#### 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` meets 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 ([[container.alloc.req]]), 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.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` 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_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
+ constexpr vector() noexcept(noexcept(Allocator())) : vector(Allocator()) { }
+ constexpr explicit vector(const Allocator&) noexcept;
+ constexpr explicit vector(size_type n, const Allocator& = Allocator());
+ constexpr vector(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr vector(InputIterator first, InputIterator last, const Allocator& = Allocator());
+ constexpr vector(const vector& x);
+ constexpr vector(vector&&) noexcept;
+ constexpr vector(const vector&, const Allocator&);
+ constexpr vector(vector&&, const Allocator&);
+ constexpr vector(initializer_list<T>, const Allocator& = Allocator());
+ constexpr ~vector();
+ constexpr vector& operator=(const vector& x);
+ constexpr vector& operator=(vector&& x)
       noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
                allocator_traits<Allocator>::is_always_equal::value);
+ constexpr vector& operator=(initializer_list<T>);
     template<class InputIterator>
+ constexpr void assign(InputIterator first, InputIterator last);
+ constexpr void assign(size_type n, const T& u);
+ constexpr void assign(initializer_list<T>);
+ constexpr allocator_type get_allocator() const noexcept;
+    // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ 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);
+ constexpr void      reserve(size_type n);
+ 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;
     // [vector.data], data access
+ constexpr T*       data() noexcept;
+ constexpr const T* data() const noexcept;
     // [vector.modifiers], modifiers
+    template<class... Args> constexpr reference emplace_back(Args&&... args);
+ constexpr void push_back(const T& x);
+ constexpr void push_back(T&& x);
+ constexpr void pop_back();
+    template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
+ constexpr iterator insert(const_iterator position, const T& x);
+ constexpr iterator insert(const_iterator position, T&& x);
+ constexpr iterator insert(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
+ constexpr iterator insert(const_iterator position,
+                                InputIterator first, InputIterator last);
+ constexpr iterator insert(const_iterator position, initializer_list<T> il);
+ constexpr iterator erase(const_iterator position);
+ constexpr iterator erase(const_iterator first, const_iterator last);
+    constexpr void     swap(vector&)
       noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
                allocator_traits<Allocator>::is_always_equal::value);
+ constexpr void     clear() noexcept;
   };
+  template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     vector(InputIterator, InputIterator, Allocator = Allocator())
+      -> vector<iter-value-type<InputIterator>, Allocator>;
+  // swap
   template<class T, class Allocator>
+ constexpr 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 meets the allocator completeness requirements
+[[allocator.requirements.completeness]]. `T` shall be complete before
 any member of the resulting specialization of `vector` is referenced.
+#### Constructors, copy, and assignment <a id="vector.cons">[[vector.cons]]</a>
 ``` cpp
+constexpr explicit vector(const Allocator&) noexcept;
 ```
 *Effects:* Constructs an empty `vector`, using the specified allocator.
 *Complexity:* Constant.
 ``` 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`.
 ``` 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`.
 ``` cpp
 template<class InputIterator>
+ constexpr vector(InputIterator first, InputIterator last,
                    const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `vector` equal to the range \[`first`, `last`),
 using the specified allocator.
 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.
+#### Capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
+constexpr size_type capacity() const noexcept;
 ```
 *Returns:* The total number of elements that the vector can hold without
 requiring reallocation.
+*Complexity:* Constant time.
 ``` 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
 `capacity()` otherwise. Reallocation happens at this point if and only
 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.
 *Complexity:* It does not change the size of the sequence and takes at
 most linear time in the size of the sequence.
 *Throws:* `length_error` if `n > max_size()`.[^4]
 *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
+call to `reserve()` until an insertion would make the size of the vector
+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
 iterators referring to the elements in the sequence as well as the
+past-the-end iterator.
+[*Note 3*: If no reallocation happens, they remain
+valid. — *end note*]
 ``` cpp
+constexpr 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`.
 *Complexity:* Constant time.
 ``` 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>
 ``` cpp
+constexpr iterator insert(const_iterator position, const T& x);
+constexpr iterator insert(const_iterator position, T&& x);
+constexpr iterator insert(const_iterator position, size_type n, const T& x);
 template<class InputIterator>
+ constexpr iterator insert(const_iterator position, InputIterator first, InputIterator last);
+constexpr iterator insert(const_iterator position, initializer_list<T>);
+template<class... Args> constexpr reference emplace_back(Args&&... args);
+template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
+constexpr void push_back(const T& x);
+constexpr 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, 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.
+*Complexity:* If reallocation happens, linear in the number of elements
+of the resulting vector; otherwise, linear in the number of elements
 inserted plus the distance to the end of the vector.
 ``` cpp
+constexpr iterator erase(const_iterator position);
+constexpr iterator erase(const_iterator first, const_iterator last);
+constexpr void pop_back();
 ```
 *Effects:* Invalidates iterators and references at or after the point of
 the erase.
 vector after the erased elements.
 *Throws:* Nothing unless an exception is thrown by the assignment
 operator or move assignment operator of `T`.
+#### 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:
+``` cpp
+auto it = remove(c.begin(), c.end(), value);
+auto r = distance(it, c.end());
+c.erase(it, c.end());
+return r;
+```
+``` cpp
+template<class T, class Allocator, class Predicate>
+  constexpr typename vector<T, Allocator>::size_type
+    erase_if(vector<T, Allocator>& c, Predicate pred);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto it = remove_if(c.begin(), c.end(), pred);
+auto r = distance(it, c.end());
+c.erase(it, c.end());
+return r;
+```

Diff to HTML by rtfpessoa