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

Files changed (1) hide show

tmp/tmpf2a2_v4s/{from.md → to.md} +28 -49

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

@@ -36,12 +36,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;
     // [deque.cons], construct/copy/destroy:
- explicit deque(const Allocator& = Allocator());
-    explicit deque(size_type n);
     deque(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
       deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
     deque(const deque& x);
     deque(deque&&);
@@ -138,24 +139,25 @@ namespace std {
 ```
 #### `deque` constructors, copy, and assignment <a id="deque.cons">[[deque.cons]]</a>
 ``` cpp
-explicit deque(const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `deque`, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
-explicit deque(size_type n);
 ```
-*Effects:* Constructs a `deque` with `n` value-initialized elements.
-*Requires:* `T` shall be `DefaultConstructible`.
 *Complexity:* Linear in `n`.
 ``` cpp
 deque(size_type n, const T& value,
@@ -176,71 +178,46 @@ template <class InputIterator>
 ```
 *Effects:* Constructs a `deque` equal to the range \[`first`, `last`),
 using the specified allocator.
-*Complexity:* `distance(first, last)`.
-``` 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);
-```
 #### `deque` capacity <a id="deque.capacity">[[deque.capacity]]</a>
 ``` 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 `DefaultConstructible`.
 ``` 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:* `T` shall be `CopyInsertable` into `*this`.
 ``` cpp
 void shrink_to_fit();
 ```
-*Remarks:* `shrink_to_fit` is a non-binding request to reduce memory
-use. The request is non-binding to allow latitude for
-implementation-specific optimizations.
 #### `deque` modifiers <a id="deque.modifiers">[[deque.modifiers]]</a>
 ``` cpp
 iterator insert(const_iterator position, const T& x);
@@ -265,12 +242,14 @@ iterators and references to elements of the deque. An insertion at
 either end of the deque invalidates all the iterators to the deque, but
 has no effect on the validity of references to elements of the deque.
 *Remarks:* If an exception is thrown other than by the copy constructor,
 move constructor, assignment operator, or move assignment operator of
-`T` 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 lesser of the distances to the beginning and end of
 the deque. Inserting a single element either at the beginning or end of
 a deque always takes constant time and causes a single call to a

     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;
     // [deque.cons], construct/copy/destroy:
+    deque() : deque(Allocator()) { }
+    explicit deque(const Allocator&);
+    explicit deque(size_type n, const Allocator& = Allocator());
     deque(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
       deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
     deque(const deque& x);
     deque(deque&&);
 ```
 #### `deque` constructors, copy, and assignment <a id="deque.cons">[[deque.cons]]</a>
 ``` cpp
+explicit deque(const Allocator&);
 ```
 *Effects:* Constructs an empty `deque`, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
+explicit deque(size_type n, const Allocator& = Allocator());
 ```
+*Effects:* Constructs a `deque` with `n` default-inserted elements using
+the specified allocator.
+*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 deque(size_type n, const T& value,
 ```
 *Effects:* Constructs a `deque` equal to the range \[`first`, `last`),
 using the specified allocator.
+*Complexity:* Linear in `distance(first, last)`.
 #### `deque` capacity <a id="deque.capacity">[[deque.capacity]]</a>
 ``` 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`.
 ``` 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`.
 ``` 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 memory use
+but does not change the size of the sequence. The request is non-binding
+to allow latitude for implementation-specific optimizations.
 #### `deque` modifiers <a id="deque.modifiers">[[deque.modifiers]]</a>
 ``` cpp
 iterator insert(const_iterator position, const T& x);
 either end of the deque invalidates all the iterators to the deque, but
 has no effect on the validity of references to elements of the deque.
 *Remarks:* If an exception is thrown other than by the copy constructor,
 move constructor, assignment operator, or move assignment operator of
+`T` there are no effects. If an exception is thrown while inserting a
+single element at either end, 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 lesser of the distances to the beginning and end of
 the deque. Inserting a single element either at the beginning or end of
 a deque always takes constant time and causes a single call to a

Diff to HTML by rtfpessoa