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

Files changed (1) hide show

tmp/tmpobw_usf0/{from.md → to.md} +44 -56

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

@@ -40,12 +40,13 @@ namespace std {
     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:
- explicit vector(const Allocator& = Allocator());
-    explicit vector(size_type n);
     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);
@@ -142,24 +143,25 @@ namespace std {
 ```
 #### `vector` constructors, copy, and assignment <a id="vector.cons">[[vector.cons]]</a>
 ``` cpp
-explicit vector(const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `vector`, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
-explicit vector(size_type n);
 ```
-*Effects:* Constructs a `vector` with `n` value-initialized elements.
-*Requires:* `T` shall be `DefaultConstructible`.
 *Complexity:* Linear in `n`.
 ``` cpp
 vector(size_type n, const T& value,
@@ -186,33 +188,10 @@ 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.
-``` cpp
-template <class InputIterator>
-  void assign(InputIterator first, InputIterator last);
-```
-*Effects:*
-``` cpp
-erase(begin(), end());
-insert(begin(), first, last);
-```
-``` cpp
-void assign(size_type n, const T& t);
-```
-*Effects:*
-``` cpp
-erase(begin(), end());
-insert(begin(), n, t);
-```
 #### `vector` capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 size_type capacity() const noexcept;
 ```
@@ -222,10 +201,12 @@ requiring reallocation.
 ``` cpp
 void reserve(size_type n);
 ```
 *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
@@ -237,22 +218,28 @@ non-`CopyInsertable` type, there are no effects.
 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. It is guaranteed
-that no reallocation takes 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();
 ```
 *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.
 ``` cpp
 void swap(vector& x);
 ```
@@ -263,34 +250,32 @@ of `x`.
 ``` cpp
 void resize(size_type sz);
 ```
-*Effects:* If `sz <= size()`, equivalent to
-`erase(begin() + sz, end());`. If `size() < sz`, appends `sz - size()`
-value-initialized elements to the sequence.
-*Requires:* `T` shall be `CopyInsertable` into `*this`.
-``` cpp
-void resize(size_type sz, const T& c);
-```
-*Effects:*
-``` cpp
-if (sz > size())
-  insert(end(), sz-size(), c);
-else if (sz < size())
-  erase(begin()+sz, end());
-else
-  ;                 // do nothing
-```
-*Requires:* If an exception is thrown other than by the move constructor
 of a non-`CopyInsertable` `T` there are no effects.
 #### `vector` data <a id="vector.data">[[vector.data]]</a>
 ``` cpp
 T*         data() noexcept;
 const T*   data() const noexcept;
@@ -320,12 +305,15 @@ 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 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

     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` 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,
 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;
 ```
 ``` 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
 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`.
+*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);
 ```
 ``` 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
 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.
 #### `vector` data <a id="vector.data">[[vector.data]]</a>
 ``` cpp
 T*         data() noexcept;
 const T*   data() const noexcept;
 *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

Diff to HTML by rtfpessoa