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

 

C++

编译器支持

独立和托管

语言

标准库

标准库头文件

具名要求

特性测试宏 (C++20)

语言支持库

概念库 (C++20)

诊断库

内存管理库

元编程库 (C++11)

通用工具库

容器库

迭代器库

范围库 (C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库 (C++17)

并发支持库 (C++11)

执行控制库 (C++26)

技术规范

符号索引

外部库

 

容器库

序列

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

关联

set

multiset

map

multimap

无序关联

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

适配器

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

视图

span (C++20)

mdspan (C++23)

表格

迭代器失效

成员函数表

非成员函数表

 

std::stack

成员函数

stack::stack

stack::~stack

stack::operator=

元素访问

stack::top

容量

stack::empty

stack::size

修改器

stack::push

stack::push_range (C++23)

stack::emplace (C++11)

stack::pop

stack::swap (C++11)

非成员函数

swap(std::stack) (C++11)

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

辅助类

uses_allocator<std::stack> (C++11)

formatter<std::stack> (C++23)

推导指引(C++17)

 

stack() : stack(Container()) {}	(1)	(自 C++11 起)
	(2)
explicit stack( const Container& cont = Container() );			(直至 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 );		(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) 使用 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>::value 为 true 时参与重载解析，即如果底层容器是 allocator-aware 容器（对于所有可以与 stack 一起使用的标准库容器都为 true）。

7) 使用 alloc 作为分配器构造底层容器，如同通过 c(alloc)。

8) 使用 cont 的内容并使用 alloc 作为分配器构造底层容器，如同通过 c(cont, alloc)。

9) 使用移动语义以及 alloc 作为分配器构造具有 cont 内容的底层容器，如同通过 c(std::move(cont), alloc)。

10) 使用 other.c 的内容并使用 alloc 作为分配器构造适配器，如同通过 c(other.c, alloc)。

11) 使用移动语义以及 alloc 作为分配器构造具有 other 内容的适配器，如同通过 c(std::move(other.c), alloc)。

12) 使用 alloc 作为分配器，使用范围 [first, last) 的内容构造底层容器，如同通过 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 的要求。

复杂度

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

注解

特性测试 宏	值	Std	特性
__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); // overload (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, overload (13)
    auto c5 = std::stack(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::stack>();
    assert(c6.size() == 42);
 
    std::allocator<int> alloc;
 
    // C++23, overload (14)
    auto c7 = std::stack(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::stack>(alloc);
    assert(c8.size() == 42);
# endif
}

缺陷报告

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

DR	应用于	已发布行为	正确行为
P0935R0	C++11	默认构造函数是显式的	设为隐式

参见

operator=

为容器适配器赋值 (public member function)