std::queue::queue

explicit queue (const container_type& ctnr = container_type());

initialize (1)	explicit queue (const container_type& ctnr);
move-initialize (2)	explicit queue (container_type&& ctnr = container_type());
allocator (3)	template <class Alloc> explicit queue (const Alloc& alloc);
init + allocator (4)	template <class Alloc> queue (const container_type& ctnr, const Alloc& alloc);
move-init + allocator (5)	template <class Alloc> queue (container_type&& ctnr, const Alloc& alloc);
copy + allocator (6)	template <class Alloc> queue (const queue& x, const Alloc& alloc);
move + allocator (7)	template <class Alloc> queue (queue&& x, const Alloc& alloc);

Construct queue

Constructs a queue container adaptor object.

A container adaptor keeps internally a container object as data. This container object is a copy of the ctnr argument passed to the constructor, if any, otherwise it is an empty container.

A container adaptor keeps internally a container object as data, which is initialized by this constructor:

(1) initialization constructor: Constructs a container adaptor whose internal container is initialized to a copy of ctnr.
(2) move-initialization constructor: Constructs a container adaptor whose internal container acquires the value of ctnr by move-constructing it.
(3) allocator constructor: Constructs a container adaptor whose internal container is constructed with alloc as argument.
(4) initialization with allocator constructor: Constructs a container adaptor whose internal container is constructed with cntr and alloc as arguments.
(5) move-initialization with allocator constructor: Constructs a container adaptor whose internal container is constructed with std::move(cntr) and alloc as arguments.
(6) copy with allocator constructor: Constructs a container adaptor whose internal container is constructed with x's internal container as first argument and alloc as second.
(7) move with allocator constructor: Constructs a container adaptor whose internal container is constructed by moving x's internal container as first argument and passing alloc as second.

Parameters

ctnr: Container object.
container_type is the type of the underlying container type (defined as an alias of the second class template parameter, Container; see member types).
alloc: Allocator object.
Alloc shall be a type for which uses_allocator::value is true (for other types, the constructor does not even participate in overload resolution).
x: A queue of the same type (i.e., with the same template arguments, T and Container).

Example

// constructing queues
#include <iostream>       // std::cout
#include <deque>          // std::deque
#include <list>           // std::list
#include <queue>          // std::queue

int main ()
{
  std::deque<int> mydeck (3,100);        // deque with 3 elements
  std::list<int> mylist (2,200);         // list with 2 elements

  std::queue<int> first;                 // empty queue
  std::queue<int> second (mydeck);       // queue initialized to copy of deque

  std::queue<int,std::list<int> > third; // empty queue with list as underlying container
  std::queue<int,std::list<int> > fourth (mylist);

  std::cout << "size of first: " << first.size() << '\n';
  std::cout << "size of second: " << second.size() << '\n';
  std::cout << "size of third: " << third.size() << '\n';
  std::cout << "size of fourth: " << fourth.size() << '\n';

  return 0;
}

Output:

size of first: 0
size of second: 3
size of third: 0
size of fourth: 2

Complexity

One container construction (which for standard containers is up to linear in its size).

Iterator validity

Moving constructors (2) and (7), may invalidate all iterators, pointers and references related to their moved argument.

Data races

All copied elements are accessed.
The moving constructors (2) and (7) may modify their (first) argument.

Exception safety

Provides the same level of guarantees as the operation performed on the container.

member functions

non-member overloads

non-member specializations