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

来自cppreference.com
See More

[编辑模板]
 
C++
 
容器库
 
std::queue
 
<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody><tbody> </tbody>
queue() : queue(Container()) {}
 (1) (C++11 起)
(2)
explicit queue( const Container& cont = Container() );
 (C++11 前)
explicit queue( const Container& cont );
 (C++11 起)
explicit queue( Container&& cont );
 (3) (C++11 起)
queue( const queue& other );
 (4) (隐式声明)
queue( queue&& other );
 (5) (C++11 起)
(隐式声明)
template< class InputIt > queue( InputIt first, InputIt last );
 (6) (C++23 起)
template< class Alloc > explicit queue( const Alloc& alloc );
 (7) (C++11 起)
template< class Alloc > queue( const Container& cont, const Alloc& alloc );
 (8) (C++11 起)
template< class Alloc > queue( Container&& cont, const Alloc& alloc );
 (9) (C++11 起)
template< class Alloc > queue( const queue& other, const Alloc& alloc );
 (10) (C++11 起)
template< class Alloc > queue( queue&& other, const Alloc& alloc );
 (11) (C++11 起)
template< class InputIt, class Alloc > queue( InputIt first, InputIt last, const Alloc& alloc );
 (12) (C++23 起)
template< container-compatible-range<T> R> queue( std::from_range_t, R&& rg );
 (13) (C++23 起)
template< container-compatible-range<T> R, class Alloc > queue( std::from_range_t, R&& rg, const Alloc& alloc );
 (14) (C++23 起)

从各种数据源构造容器适配器的新底层容器。

1) 默认构造函数。值初始化容器。
2) 以 cont 的内容复制构造底层容器 c。此亦为默认构造函数。(C++11 前)
3) 以 std::move(cont) 移动构造底层容器 c。
4) 复制构造函数。以 other.c 的内容复制构造适配器。
5) 移动构造函数。以 std::move(other.c) 构造适配器。
6) 以范围 [first, last) 的内容构造底层容器 c。此重载只有在 InputIt 满足老式输入迭代器 (LegacyInputIterator) 时才会参与重载决议。
7-12) 这些构造函数仅若 std::uses_allocator<Container, Alloc> 为 true，即底层容器是知分配器容器时才参与重载决议（对可以同 queue 一起使用的所有标准库容器均为真）。
7) 以 alloc 为分配器构造底层容器，如同调用 c(alloc)。
8) 用 cont 的内容，并以 alloc 为分配器构造底层容器，如同调用 c(cont, alloc)。
9) 以 cont 的内容用移动语义，同时以 alloc 为分配器构造底层容器，如同调用 c(std::move(cont), alloc)。
10) 以 other.c 的内容，并以 alloc 为分配器构造适配器，如同调用 c(other.c, alloc)。
11) 以 other 的内容使用移动语义，并以 alloc 为分配器构造适配器，如同调用 c(std::move(other.c), alloc)。
12) 以范围 [first, last) 的内容并以 alloc 为分配器构造底层容器，如同调用 c(first, last, alloc)。此重载只有在 InputIt 满足老式输入迭代器 (LegacyInputIterator) 时才会参与重载决议。
13) 以 ranges::to<Container>(std::forward<R>(rg)) 构造底层容器。
14) 以 ranges::to<Container>(std::forward<R>(rg), alloc) 构造底层容器。

参数

alloc - 用于底层容器所有内存分配的分配器
other - 用作初始化底层容器的源的另一容器适配器
cont - 用作初始化底层容器的源的容器
first, last - 用以初始化的源元素范围的迭代器对
rg - 容器兼容范围，即其元素可转换为 T 的 input_range
类型要求
-
Alloc 必须满足分配器 (Allocator) 。
-
Container 必须满足容器 (Container) 。接受一个分配器参数的构造函数仅若 Container 满足知分配器容器 (AllocatorAwareContainer) 的要求参与重载决议。
-
InputIt 必须满足老式输入迭代器 (LegacyInputIterator) 。

复杂度

与被包装容器上的对应操作相同。

注解

功能特性测试宏 值 标准 功能特性
__cpp_lib_adaptor_iterator_pair_constructor 202106L (C++23) 用于 std::queue 和 std::stack 的迭代器对构造函数; 重载 (6) 和 (12)
__cpp_lib_containers_ranges 202202L (C++23) 按范围构造和插入; 重载 (13) 和 (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); // 重载 (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, 重载 (13)
    auto c5 = std::queue(std::from_range_t, std::ranges::iota(0, 42));
    assert(c5.size() == 42);

    // 效果相同的管道语法，内部使用重载 (13)
    auto c6 = std::ranges::iota(0, 42) | std::ranges::to<std::queue>();
    assert(c6.size() == 42);

    std::allocator<int> alloc;

    // C++23, 重载 (14)
    auto c7 = std::queue(std::from_range_t, std::ranges::iota(0, 42), alloc);
    assert(c7.size() == 42);

    // 效果相同的管道语法，内部使用重载 (14)
    auto c8 = std::ranges::iota(0, 42) | std::ranges::to<std::queue>(alloc);
    assert(c8.size() == 42);
# endif
}

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 出版时的行为 正确行为
P0935R0 C++11 默认构造函数曾为 explicit 使之为隐式

参阅

 将值赋给容器适配器
(公开成员函数) [编辑]