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 InputIt > queue( InputIt first, InputIt last ); | (6) | (since C++23) |
template< class Alloc > explicit queue( const Alloc& alloc ); | (7) | (since C++11) |
template< class Alloc > queue( const Container& cont, const Alloc& alloc ); | (8) | (since C++11) |
template< class Alloc > queue( Container&& cont, const Alloc& alloc ); | (9) | (since C++11) |
template< class Alloc > queue( const queue& other, const Alloc& alloc ); | (10) | (since C++11) |
template< class Alloc > queue( queue&& other, const Alloc& alloc ); | (11) | (since C++11) |
template< class InputIt, class Alloc > queue( InputIt first, InputIt last, const Alloc& alloc ); | (12) | (since C++23) |
template< container-compatible-range<T> R> queue( std::from_range_t, R&& rg ); | (13) | (since C++23) |
template< container-compatible-range<T> R, class Alloc > queue( std::from_range_t, R&& rg, const Alloc& alloc ); | (14) | (since C++23) |
Constructs new underlying container of the container adaptor from a variety of data sources.
c
with the contents of cont
. This is also the default constructor. (until C++11)
c
with std::move(cont)
.other.c
. (implicitly declared)
c
with the contents of the range [
first
,
last
)
. This overload participates in overload resolution only if InputIt
satisfies LegacyInputIterator.std::uses_allocator<Container, Alloc>::value
is true
, that is, if the underlying container is an allocator-aware container (true for all standard library containers that can be used with queue
).alloc
as allocator, as if by c(alloc)
.cont
and using alloc
as allocator, as if by c(cont, alloc)
.cont
using move semantics while utilizing alloc
as allocator, as if by c(std::move(cont), alloc)
.other.c
and using alloc
as allocator, as if by c(other.c, alloc)
.other
using move semantics while utilizing alloc
as allocator, as if by c(std::move(other.c), alloc)
.[
first
,
last
)
using alloc
as allocator, as if by c(first, last, alloc)
. This overload participates in overload resolution only if InputIt
satisfies LegacyInputIterator.ranges::to<Container>(std::forward<R>(rg))
.ranges::to<Container>(std::forward<R>(rg), alloc)
.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 [ first , last ) to initialize with |
rg | - | a container compatible range, that is, an input_range whose elements are convertible to T |
Type requirements | ||
-Alloc must meet the requirements of Allocator. |
||
-Container must meet the requirements of Container. The constructors taking an allocator parameter participate in overload resolution only if Container meets the requirements of AllocatorAwareContainer. |
||
-InputIt must meet the requirements of LegacyInputIterator. |
Same as the corresponding operation on the wrapped container.
Feature-test macro | Value | Std | Comment |
---|---|---|---|
__cpp_lib_adaptor_iterator_pair_constructor | 202106L | (C++23) | Iterator pair constructors for std::queue and std::stack ; overloads (6) and (12) |
__cpp_lib_containers_ranges | 202202L | (C++23) | Ranges-aware construction and insertion; overloads (13) and (14) |
#include <cassert> #include <deque> #include <iostream> #include <memory> #include <ranges> #include <queue> int main() { std::queue<int> c1; c1.push(5); assert(c1.size() == 1); std::queue<int> c2(c1); assert(c2.size() == 1); std::deque<int> deq {3, 1, 4, 1, 5}; std::queue<int> c3(deq); // overload (2) assert(c3.size() == 5); # ifdef __cpp_lib_adaptor_iterator_pair_constructor const auto il = {2, 7, 1, 8, 2}; std::queue<int> c4{ il.begin(), il.end() }; // C++23, (6) assert(c4.size() == 5); # endif # if __cpp_lib_containers_ranges >= 202202L // C++23, overload (13) auto c5 = std::queue(std::from_range_t, std::ranges::iota(0, 42)); assert(c5.size() == 42); // the same effect with pipe syntax, internally uses overload (13) auto c6 = std::ranges::iota(0, 42) | std::ranges::to<std::queue>(); assert(c6.size() == 42); std::allocator<int> alloc; // C++23, overload (14) auto c7 = std::queue(std::from_range_t, std::ranges::iota(0, 42), alloc); assert(c7.size() == 42); // the same effect with pipe syntax, internally uses overload (14) auto c8 = std::ranges::iota(0, 42) | std::ranges::to<std::queue>(alloc); assert(c8.size() == 42); # endif }
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 |
assigns values to the container adaptor (public member function) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/container/queue/queue