std::queue<T,Container>::queue

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical Specifications

 

Containers library

Sequence

array (C++11)

vector

deque

forward_list (C++11)

list

Associative

set

multiset

map

multimap

Unordered associative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptors

stack

queue

priority_queue

Views

span (C++20)

 

std::queue

Member functions

queue::queue

queue::~queue

queue::operator=

Element access

queue::front

queue::back

Capacity

queue::empty

queue::size

Modifiers

queue::push

queue::emplace

queue::pop

queue::swap

Non-member functions

operator==operator!=operator<operator>operator<=operator>=operator<=> (C++20)

std::swap

Deduction guides(C++17)

 

queue() : queue(Container()) { }	(1)	(since C++11)
	(2)
explicit queue( const Container& cont = Container() );			(until C++11)
explicit queue( const Container& cont );			(since C++11)
explicit queue( Container&& cont );		(3)	(since C++11)
queue( const queue& other );		(4)
queue( queue&& other );		(5)	(since C++11)
template< class Alloc > explicit queue( const Alloc& alloc );		(6)	(since C++11)
template< class Alloc > queue( const Container& cont, const Alloc& alloc );		(7)	(since C++11)
template< class Alloc > queue( Container&& cont, const Alloc& alloc );		(8)	(since C++11)
template< class Alloc > queue( const queue& other, const Alloc& alloc );		(9)	(since C++11)
template< class Alloc > queue( queue&& other, const Alloc& alloc );		(10)	(since C++11)

Constructs new underlying container of the container adaptor from a variety of data sources.

1) Default constructor. Value-initializes the container.

2) Copy-constructs the underlying container c with the contents of cont. This is also the default constructor. (until C++11)

3) Move-constructs the underlying container c with std::move(cont).

4) Copy constructor. The adaptor is copy-constructed with the contents of other.c. (implicitly declared)

5) Move constructor. The adaptor is constructed with std::move(other.c). (implicitly declared)

6-10) The following constructors are only defined if std::uses_allocator<container_type, Alloc>::value == true, that is, if the underlying container is an allocator-aware container (true for all standard library containers that can be used with queue).

6) Constructs the underlying container using alloc as allocator, as if by c(alloc).

7) Constructs the underlying container with the contents of cont and using alloc as allocator, as if by c(cont, alloc).

8) Constructs the underlying container with the contents of cont using move semantics while utilizing alloc as allocator, as if by c(std::move(cont), alloc).

9) Constructs the adaptor with the contents of other.c and using alloc as allocator, as if by c(other.c, alloc).

10) Constructs the adaptor with the contents of other using move semantics while utilizing alloc as allocator, as if by c(std::move(other.c), alloc).

Parameters

alloc	-	allocator to use for all memory allocations of the underlying container
other	-	another container adaptor to be used as source to initialize the underlying container
cont	-	container to be used as source to initialize the underlying container
first, last	-	range of elements to initialize with
Type requirements
- Alloc must meet the requirements of Allocator.
- Container must meet the requirements of Container. The constructors (6-10) are only defined if Container meets the requirements of AllocatorAwareContainer
- InputIt must meet the requirements of LegacyInputIterator.

Complexity

Same as the corresponding operation on the wrapped container.

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
P0935R0	C++11	default constructor was explicit	made implicit

Example

Run this code

#include <queue>
#include <deque>
#include <iostream>
 
int main()
{
    std::queue<int> c1;
    c1.push(5);
    std::cout << c1.size() << '\n';
 
    std::queue<int> c2(c1);
    std::cout << c2.size() << '\n';
 
    std::deque<int> deq {3, 1, 4, 1, 5};
    std::queue<int> c3(deq);
    std::cout << c3.size() << '\n';
}

Output:

1
1
5

See also

operator=

assigns values to the container adaptor (public member function)