标准库标头 <stack>

 

C++

编译器支持

自立实现与有宿主实现

语言

标准库

标准库标头

具名要求

功能特性测试宏 (C++20)

语言支持库

概念库 (C++20)

元编程库 (C++11)

诊断库

通用工具库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

并发支持库 (C++11)

技术规范

符号索引

外部库

 

标准库标头

注：修订记号中的反斜杠 '/' 意味着此标头被弃用和/或被移除。

语言支持
<cstddef> <cstdlib> <version> (C++20) <limits> <climits>	<cfloat> <cstdint> (C++11) <stdfloat> (C++23) <new> <typeinfo>	<source_location> (C++20) <exception> <initializer_list> (C++11) <compare> (C++20)	<coroutine> (C++20) <csignal> <csetjmp> <cstdarg>
概念
<concepts> (C++20)
诊断
<stdexcept> <stacktrace> (C++23)	<cassert>	<cerrno>	<system_error> (C++11)
内存管理
<memory>	<memory_resource> (C++17)	<scoped_allocator> (C++11)
元编程
<type_traits> (C++11)	<ratio> (C++11)
通用工具
<utility> <tuple> (C++11) <optional> (C++17) <variant> (C++17)	<any> (C++17) <expected> (C++23) <bitset>	<functional> <typeindex> (C++11) <execution> (C++17)	<charconv> (C++17) <format> (C++20) <bit> (C++20)
字符串
<string_view> (C++17) <string>	<cctype> <cwctype>	<cstring> <cwchar>	<cuchar> (C++11)
容器
<array> (C++11) <deque> <forward_list> (C++11) <list>	<vector> <map> <set> <unordered_map> (C++11)	<unordered_set> (C++11) <queue> <stack> <flat_map> (C++23)	<flat_set> (C++23) <span> (C++20) <mdspan> (C++23)
迭代器
<iterator>
范围
<ranges> (C++20)	<generator> (C++23)
算法
<algorithm>	<execution>
数值
<cfenv> (C++11) <complex>	<random> (C++11) <valarray>	<cmath>	<numbers> (C++20)
日期时间
<chrono> (C++11)	<ctime>
本地化
<locale>	<clocale>	<codecvt> (C++11/17)
输入/输出
<iosfwd> <iostream> <ios> <streambuf>	<istream> <ostream> <iomanip> <print> (C++23)	<sstream> <spanstream> (C++23) <fstream> <syncstream> (C++20)	<filesystem> (C++17) <cstdio> <cinttypes> (C++11) <strstream> (C++98/)
正则表达式
<regex>
并发支持
<stop_token> (C++20) <thread> (C++11) <atomic> (C++11)	<stdatomic.h> (C++23) <mutex> (C++11) <shared_mutex> (C++14)	<condition_variable> (C++11)   <semaphore> (C++20) <latch> (C++20)	<barrier> (C++20) <future> (C++11)
C 兼容
<cstdbool> (C++11/17/20)   <ccomplex> (C++11/17/20)	<ctgmath> (C++11/17/20)	<cstdalign> (C++11/17/20)	<ciso646> (C++20 前)

 

此头文件是容器库的一部分。

包含
<compare> (C++20)	三路比较运算符支持
<initializer_list> (C++11)	std::initializer_list 类模板
类
stack	适配一个容器以提供栈（LIFO 数据结构） (类模板)
std::uses_allocator<std::stack> (C++11)	特化 std::uses_allocator 类型特征 (类模板特化)
函数
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)	按照字典顺序比较 stack 中的值 (函数模板)
std::swap(std::stack) (C++11)	特化 std::swap 算法 (函数模板)

概要

#include <compare>
#include <initializer_list>
 
namespace std {
  template<class T, class Container = deque<T>> class stack;
 
  template<class T, class Container>
    bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
  template<class T, class Container>
    bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
  template<class T, class Container>
    bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
  template<class T, class Container>
    bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
  template<class T, class Container>
    bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
  template<class T, class Container>
    bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
  template<class T, three_way_comparable Container>
    compare_three_way_result_t<Container>
      operator<=>(const stack<T, Container>& x, const stack<T, Container>& y);
 
  template<class T, class Container>
    void swap(stack<T, Container>& x, stack<T, Container>& y)
      noexcept(noexcept(x.swap(y)));
  template<class T, class Container, class Alloc>
    struct uses_allocator<stack<T, Container>, Alloc>;
}

类模板 std::stack

namespace std {
  template<class T, class Container = deque<T>>
  class stack {
  public:
    using value_type      = typename Container::value_type;
    using reference       = typename Container::reference;
    using const_reference = typename Container::const_reference;
    using size_type       = typename Container::size_type;
    using container_type  = Container;
 
  protected:
    Container c;
 
  public:
    stack() : stack(Container()) {}
    explicit stack(const Container&);
    explicit stack(Container&&);
    template<class InputIt> stack(InputIt first, InputIt last);
    template<class Alloc> explicit stack(const Alloc&);
    template<class Alloc> stack(const Container&, const Alloc&);
    template<class Alloc> stack(Container&&, const Alloc&);
    template<class Alloc> stack(const stack&, const Alloc&);
    template<class Alloc> stack(stack&&, const Alloc&);
    template<class InputIt, class Alloc>
      stack(InputIt first, InputIt last, const Alloc&);
 
    [[nodiscard]] bool empty() const    { return c.empty(); }
    size_type size()  const             { return c.size(); }
    reference         top()             { return c.back(); }
    const_reference   top() const       { return c.back(); }
    void push(const value_type& x)      { c.push_back(x); }
    void push(value_type&& x)           { c.push_back(std::move(x)); }
    template<class... Args>
      decltype(auto) emplace(Args&&... args)
        { return c.emplace_back(std::forward<Args>(args)...); }
    void pop()                          { c.pop_back(); }
    void swap(stack& s) noexcept(is_nothrow_swappable_v<Container>)
      { using std::swap; swap(c, s.c); }
  };
 
  template<class Container>
    stack(Container) -> stack<typename Container::value_type, Container>;
 
  template<class InputIt>
    stack(InputIt, InputIt) -> stack</*iter-value-type*/<InputIt>>;
 
  template<class Container, class Allocator>
    stack(Container, Allocator) -> stack<typename Container::value_type, Container>;
 
  template<class InputIt, class Allocator>
    stack(InputIt, InputIt, Allocator)
      -> stack</*iter-value-type*/<InputIt>, deque</*iter-value-type*/<InputIt>,
               Allocator>>;
 
  template<class T, class Container, class Alloc>
    struct uses_allocator<stack<T, Container>, Alloc>
      : uses_allocator<Container, Alloc>::type { };
}