std::queue::queue(3)

💖 std::queue::queue — C++ Standard Libary, section 3 💖

Okay bestie, welcome to the std::queue::queue(3) page — we’re in the C++ Standard Libary (their spelling, not mine 💅), section 3, and this is all about constructing a std::queue. It’s giving “constructor lore” and honestly? Iconic. ✨

---

💖 NAME 💖

std::queue::queue - std::queue::queue

Yes, the NAME section is literally the constructor name echoing itself. Main character energy. We love a self-referential moment. 🫶

🌸 Synopsis 🌸

Here’s the synopsis exactly as printed; the alignment is doing a lot, but we respect it. 💅

queue() : queue(Container()) {}                     (1) (since C++11)
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)
(implicitly declared)
(since C++11)
queue( queue&& other );                                 (5)
(implicitly declared)
template< class InputIt >                               (6)
(since C++23)
queue( InputIt first, InputIt last );
template< class Alloc >                                 (7)
(since C++11)
explicit queue( const Alloc& alloc );
template< class Alloc >                                 (8)
(since C++11)
queue( const Container& cont, const Alloc& alloc ); (2)
template< class Alloc >                                 (9)
(since C++11)
queue( Container&& cont, const Alloc& alloc );
template< class Alloc >                                 (10)
(since C++11)
queue( const queue& other, const Alloc& alloc );
template< class Alloc >                                 (11)
(since C++11)
queue( queue&& other, const Alloc& alloc );
template< class InputIt, class Alloc >
queue( InputIt first, InputIt last, const Alloc&        (12)
(since C++23)
alloc );
template< container-compatible-range<T> R>              (13)
(since C++23)
queue( std::from_range_t, R&& rg );
template< container-compatible-range<T> R, class
Alloc >                                                 (14)
(since C++23)
queue( std::from_range_t, R&& rg, const Alloc&
alloc );

Okay so the big vibe: it constructs a new underlying container of the container adaptor from a variety of data sources. Here’s the overload-by-overload tea:

• 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.
• 5) Move constructor. The adaptor is constructed with std::move(other.c).
• 6) Constructs the underlying container c with the contents of the range [first, last). This overload participates in overload resolution only if InputIt satisfies LegacyInputIterator.
• 7–12) These constructors participate in overload resolution only if 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).
• 7) Constructs the underlying container using alloc as allocator, as if by c(alloc).
• 8) Constructs the underlying container with the contents of cont and using alloc as allocator, as if by c(cont, alloc).
• 9) 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).
• 10) Constructs the adaptor with the contents of other.c and using alloc as allocator, as if by c(other.c, alloc).
• 11) 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).
• 12) Constructs the underlying container with the contents of the range [first, last) using alloc as allocator, as if by c(first, last, alloc). This overload participates in overload resolution only if InputIt satisfies LegacyInputIterator.
• 13) Constructs the underlying container with ranges::to<Container>(std::forward<R>(rg)).
• 14) Constructs the underlying container with ranges::to<Container>(std::forward<R>(rg), 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 [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.

⭐ Complexity ⭐

Same as the corresponding operation on the wrapped container.

👑 Notes 👑

Feature-test macro tea, bestie:

• __cpp_lib_adaptor_iterator_pair_constructor — value 202106L, standard (C++23). Feature: Iterator pair constructors for std::queue and std::stack; overloads (6) and (12).
• __cpp_lib_containers_ranges — value 202202L, standard (C++23). Feature: Ranges-aware construction and insertion; overloads (13) and (14).

🌈 Example 🌈

Run this code, bestie — it’s literally right there:

// Run this code

#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
}

💀 Defect reports 💀

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

• P0935R0 — applied to C++11. Behavior as published: default constructor was explicit. Correct behavior: made implicit.

🍓 See also 🍓

• operator= — assigns values to the container adaptor (public member function).

xoxo, your Unix bestie 💅 — source: http://cppreference.com, version/date 2024.06.10, page std::queue::queue(3). Periodt. 👑