public member function

std::deque::deque

<deque>
default (1)
explicit deque (const allocator_type& alloc = allocator_type());
fill (2)
explicit deque (size_type n, const value_type& val = value_type(),
                const allocator_type& alloc = allocator_type());
range (3)
template <class InputIterator>
  deque (InputIterator first, InputIterator last,
         const allocator_type& alloc = allocator_type());
copy (4)
deque (const deque& x);
default (1)
explicit deque (const allocator_type& alloc = allocator_type());
fill (2)
explicit deque (size_type n);
         deque (size_type n, const value_type& val,
                const allocator_type& alloc = allocator_type());
range (3)
template <class InputIterator>
  deque (InputIterator first, InputIterator last,
         const allocator_type& alloc = allocator_type());
copy (4)
deque (const deque& x);
deque (const deque& x, const allocator_type& alloc);
move (5)
deque (deque&& x);
deque (deque&& x, const allocator_type& alloc);
initializer list (6)
deque (initializer_list<value_type> il,
       const allocator_type& alloc = allocator_type());
Construct deque container
Constructs a deque container object, initializing its contents depending on the constructor version used:

(1) empty container constructor (default constructor)
Constructs an empty container, with no elements and a size of zero.
(2) fill constructor
Initializes the container object with a size of n elements. Each object is a copy if val (if provided), or value-initialized (if val is not provided).
(3) range constructor
Constructs a deque object containing copies of each of the elements in the range [first,last), in the same order.
(4) copy constructor (and copying with allocator)
The object is initialized to have the same contents and properties as the x deque container.
(5) move constructor (and moving with allocator)
The object acquires the contents of x.
(6) initializer list constructor
Initializes the container with the contents of the il list.

The container keeps an internal copy of alloc, which is used to allocate storage throughout its lifetime.
The copy constructor (4) creates a container that keeps and uses a copy of x's allocator.
The container keeps an internal copy of alloc, which is used to allocate and deallocate storage for its elements, and to construct and destroy them (as specified by its allocator_traits).
The copy constructor (4, first signature) creates a container that keeps and uses a copy of the allocator returned by calling the appropriate selected_on_container_copy_construction trait on x's allocator.
The move constructor (5, first signature) acquires x's allocator.

Parameters

alloc
Allocator object.
The container keeps and uses an internal copy of this allocator.
Member type allocator_type is the internal allocator type used by the container, defined in deque as an alias of its second template parameter (Alloc).
If allocator_type is an instantiation of the default allocator (which has no state), this is not relevant.
n
Initial container size (i.e., the number of elements in the container at construction).
Member type size_type is an unsigned integral type.
val
Value to fill the container with. Each of the n elements in the container will be initialized to a copy of this value.
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).
first, last
Input iterators to the initial and final positions in a range. The range used is [first,last), which includes all the elements between first and last, including the element pointed by first but not the element pointed by last.
The function template argument InputIterator shall be an input iterator type that points to elements implicitly convertible to value_type.
x
Another deque object of the same type (with the same class template arguments T and Alloc), whose contents are either copied or moved.
il
An initializer_list object.
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).

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
// constructing deques
#include <iostream>
#include <deque>

int main ()
{
  unsigned int i;

  // constructors used in the same order as described above:
  std::deque<int> first;                                // empty deque of ints
  std::deque<int> second (4,100);                       // four ints with value 100
  std::deque<int> third (second.begin(),second.end());  // iterating through second
  std::deque<int> fourth (third);                       // a copy of third

  // the iterator constructor can be used to copy arrays:
  int myints[] = {16,2,77,29};
  std::deque<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );

  std::cout << "The contents of fifth are:";
  for (std::deque<int>::iterator it = fifth.begin(); it!=fifth.end(); ++it)
    std::cout << ' ' << *it;

  std::cout << '\n';

  return 0;
}

Output:
The contents of fifth are: 16 2 77 29

Complexity

Constant for the default constructor (1), and for the move constructors (5) (unless alloc is different from x's allocator).
For all other cases, linear in the resulting container size.

Data races

All copied elements are accessed.
The move constructors (5) modify x.

Exception safety

Strong guarantee: no effects in case an exception is thrown.
It throws if any operation on the elements, the allocator or the iterators throws.

See also

deque::operator=
Copy container content (public member function )
deque::assign
Assign container content (public member function )
deque::resize
Change size (public member function )
deque::clear
Clear content (public member function )

C++