Namespaces
Variants

    std::stack<T,Container>::stack

    来自 zh.cppreference.net

     
    C++
     
    容器库
     
    std::stack
     
    stack() : stack(Container()) {}
    		(1) (C++11 起) 
    explicit stack( const Container& cont = Container() );
    		(2) (C++11 前) 
    explicit stack( const Container& cont );
    		(C++11 起) 
    explicit stack( Container&& cont );
    		(3) (C++11 起) 
    stack( const stack& other );
    		(4) (隐式声明) 
    stack( stack&& other );
    		(5) (C++11 起)
    (隐式声明) 
    template< class InputIt >
stack( InputIt first, InputIt last );
    		(6) (C++23 起) 
    template< class Alloc >
explicit stack( const Alloc& alloc );
    		(7) (C++11 起) 
    template< class Alloc >
stack( const Container& cont, const Alloc& alloc );
    		(8) (C++11 起) 
    template< class Alloc >
stack( Container&& cont, const Alloc& alloc );
    		(9) (C++11 起) 
    template< class Alloc >
stack( const stack& other, const Alloc& alloc );
    		(10) (C++11 起) 
    template< class Alloc >
stack( stack&& other, const Alloc& alloc );
    		(11) (C++11 起) 
    template< class InputIt, class Alloc >
stack( InputIt first, InputIt last, const Alloc& alloc );
    		(12) (C++23 起) 
    template< container-compatible-range<T> R>
stack( std::from_range_t, R&& rg );
    		(13) (C++23 起) 
    template< container-compatible-range<T> R, class Alloc >
stack( std::from_range_t, R&& rg, const Alloc& alloc );
    		(14) (C++23 起)

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

    1) 默认构造函数。值初始化容器。
    2) 复制构造底层容器 c 以 cont。这也是默认构造函数。(C++11 前)
    3) 移动构造底层容器 c 以 std::move(cont)。
    4) 复制构造函数。other.c 适配器是用
    。 移动构造函数。std::move(other.c) 适配器是用
    。6) c 构造底层容器 [first, last) 以范围 InputIt 的内容。仅当 满足 LegacyInputIterator
    时，此重载参与重载决议。7-12)std::uses_allocator<Container, Alloc>::value 这些构造函数仅当 true 是 stack 时才参与重载决议，即底层容器是分配器感知的容器（对于所有可与
    一起使用的标准库容器均为真）。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 <stack>
int main()
{
    std::stack<int> c1;
    c1.push(5);
    assert(c1.size() == 1);
    std::stack<int> c2(c1);
    assert(c2.size() == 1);
    std::deque<int> deq{3, 1, 4, 1, 5};
    std::stack<int> c3(deq); // 重载 (2)
    assert(c3.size() == 5);
# ifdef __cpp_lib_adaptor_iterator_pair_constructor
    const auto il = {2, 7, 1, 8, 2};
    std::stack<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::stack(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::stack>();
    assert(c6.size() == 42);
    std::allocator<int> alloc;
    // C++23, 重载 (14)
    auto c7 = std::stack(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::stack>(alloc);
    assert(c8.size() == 42);
# endif
}

    缺陷报告

    以下行为变更缺陷报告被追溯应用于先前发布的C++标准。

    缺陷报告 适用范围 发布时的行为 正确行为
    P0935R0 C++11 默认构造函数为显式 改为隐式

    另请参阅

    		为容器适配器赋值
    (公开成员函数)