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_front(Args&&... args);
template <class... Args> reference emplace_back(Args&&... args);
template <class... Args> iterator emplace(const_iterator position, Args&&... args);
void push_front(const T& x);
void push_front(T&& x);
void push_back(const T& x);
void push_back(T&& x);
Effects:
An insertion in the middle of the deque invalidates all the 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 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 constructor of
T.iterator erase(const_iterator position);
iterator erase(const_iterator first, const_iterator last);
void pop_front();
void pop_back();
Effects:
An erase operation that erases the last element of a deque invalidates only the past-the-end iterator
and all iterators and references to the erased elements
. An erase operation that erases the first
element of a deque but not the last element invalidates only iterators
and references to the erased elements
.An erase operation
that erases neither the first element nor the last element of a deque invalidates the past-the-end
iterator and all iterators and references to all the elements of the deque
.[
Note: pop_front and
pop_back are erase operations
. —
end note ]
Complexity:
The number of calls to the destructor of
T is the same as the
number of elements erased, but the number of calls to the assignment operator of
T is
no more than the lesser of the number of elements before the erased elements and the number of elements 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.