RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cplusplus.com/reference/deque/deque/insert/ below:

public member function

<deque>

std::deque::insert single element (1)

iterator insert (iterator position, const value_type& val);

fill (2)

    void insert (iterator position, size_type n, const value_type& val);

range (3)

template <class InputIterator>    void insert (iterator position, InputIterator first, InputIterator last);

single element (1)

iterator insert (const_iterator position, const value_type& val);

fill (2)

iterator insert (const_iterator position, size_type n, const value_type& val);

range (3)

template <class InputIterator>iterator insert (const_iterator position, InputIterator first, InputIterator last);

move (4)

iterator insert (const_iterator position, value_type&& val);

initializer list (5)

iterator insert (const_iterator position, initializer_list<value_type> il);

Insert elements

The deque container is extended by inserting new elements before the element at the specified position.

This effectively increases the container size by the amount of elements inserted.

Double-ended queues are designed to be efficient performing insertions (and removals) from either the end or the beginning of the sequence. Insertions on other positions are usually less efficient than in list or forward_list containers.

The parameters determine how many elements are inserted and to which values they are initialized:

Parameters

position: Position in the container where the new elements are inserted.
iterator is a member type, defined as a random access iterator type that points to elements.
val: Value to be copied (or moved) to the inserted elements.
Member type value_type is the type of the elements in the container, defined in deque as an alias of its first template parameter (T).
n: Number of elements to insert. Each element is initialized to a copy of val.
Member type size_type is an unsigned integral type.
first, last: Iterators specifying a range of elements. Copies of the elements in the range [first,last) are inserted at position (in the same order).
Notice that the range includes all the elements between first and last, including the element pointed by first but not the one pointed by last.
The function template argument InputIterator shall be an input iterator type that points to elements of a type from which value_type objects can be constructed.
il: An initializer_list object. Copies of these elements are inserted at position (in the same order).
These objects are automatically constructed from initializer list declarators.
Member type value_type is the type of the elements in the container, defined in deque as an alias of its first template parameter (T).

Return value An iterator that points to the first of the newly inserted elements.

Member type iterator is a random access iterator type that points to elements.

The storage for the new elements is allocated using the container's allocator, which may throw exceptions on failure (for the default allocator, bad_alloc is thrown if the allocation request does not succeed).

Example

// inserting into a deque
#include <iostream>
#include <deque>
#include <vector>

int main ()
{
  std::deque<int> mydeque;

  // set some initial values:
  for (int i=1; i<6; i++) mydeque.push_back(i); // 1 2 3 4 5

  std::deque<int>::iterator it = mydeque.begin();
  ++it;

  it = mydeque.insert (it,10);                  // 1 10 2 3 4 5
  // "it" now points to the newly inserted 10

  mydeque.insert (it,2,20);                     // 1 20 20 10 2 3 4 5
  // "it" no longer valid!

  it = mydeque.begin()+2;

  std::vector<int> myvector (2,30);
  mydeque.insert (it,myvector.begin(),myvector.end());
                                                // 1 20 30 30 20 10 2 3 4 5

  std::cout << "mydeque contains:";
  for (it=mydeque.begin(); it!=mydeque.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

Output:

mydeque contains: 1 20 30 30 20 10 2 3 4 5

Complexity Linear on the number of elements inserted (copy/move construction). Plus, depending on the particular library implemention, up to an additional linear in the number of elements between position and one of the ends of the deque.

Iterator validity If the insertion happens at the beginning or the end of the sequence, all iterators related to this container are invalidated, but pointers and references remain valid, referring to the same elements they were referring to before the call.
If the insertion happens anywhere else in the deque, all iterators, pointers and references related to this container are invalidated.

Data races The container is modified.
If the insertion happens at the beginning or the end of the sequence, no contained elements are accessed (although see iterator validity above).
If it happens anywhere else, it is not safe to concurrently access elements.

Exception safety If the operation inserts a single element at the begin or the end, there are no changes in the container in case of exception (strong guarantee).
Otherwise, the container is guaranteed to end in a valid state (basic guarantee).
If allocator_traits::construct is not supported with the appropriate arguments for the element constructions, or if an invalid position or range is specified, it causes undefined behavior.

See also

deque::push_back: Add element at the end (public member function)

deque::push_front: Insert element at beginning (public member function)

deque::erase: Erase elements (public member function)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4