Difference between revisions of "cpp/container/stack"

Latest revision as of 15:41, 1 November 2024

Defined in header `<stack>`
template< class T, class Container = std::deque<T> > class stack;

The std::stack class is a container adaptor that gives the programmer the functionality of a stack - specifically, a LIFO (last-in, first-out) data structure.

The class template acts as a wrapper to the underlying container - only a specific set of functions is provided. The stack pushes and pops the element from the back of the underlying container, known as the top of the stack.

(constructor)	constructs the `stack` (public member function) [edit]
(destructor)	destructs the `stack` (public member function) [edit]
operator=	assigns values to the container adaptor (public member function) [edit]
Element access
top	accesses the top element (public member function) [edit]
Capacity
empty	checks whether the container adaptor is empty (public member function) [edit]
size	returns the number of elements (public member function) [edit]
Modifiers
push	inserts element at the top (public member function) [edit]
push_range (C++23)	inserts a range of elements at the top (public member function) [edit]
emplace (C++11)	constructs element in-place at the top (public member function) [edit]
pop	removes the top element (public member function) [edit]
swap (C++11)	swaps the contents (public member function) [edit]

[edit] Non-member functions

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)	lexicographically compares the values of two `stack`s (function template) [edit]
std::swap(std::stack) (C++11)	specializes the std::swap algorithm (function template) [edit]

[edit] Helper classes

std::uses_allocator<std::stack> (C++11)	specializes the std::uses_allocator type trait (class template specialization) [edit]
std::formatter<std::stack> (C++23)	formatting support for `std::stack` (class template specialization) [edit]

Deduction guides

(since C++17)

[edit] Notes

Feature-test macro	Value	Std	Feature
`__cpp_lib_containers_ranges`	202202L	(C++23)	Ranges construction and insertion for containers

[edit] Example

[edit] Defect reports

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

DR	Applied to	Behavior as published	Correct behavior
LWG 307	C++98	`Container` could not be `std::vector<bool>`	allowed
LWG 2566	C++98	Missing the requirement for `Container::value_type`	ill-formed if `T` is not the same type as `Container::value_type`

[edit] See also

vector	dynamic contiguous array (class template) [edit]
vector<bool>	space-efficient dynamic bitset (class template specialization) [edit]
deque	double-ended queue (class template) [edit]
list	doubly-linked list (class template) [edit]

@@ Line 1: / Line 1: @@
 {{cpp/title|stack}}
 {{cpp/container/stack/navbar}}
-{{ddcl | header=stack |
+{{ddcl|header=stack|1=
 template<
      class T,
-     class Container {{=}} std::deque<T>
+     class Container = std::deque<T>
 > class stack;
 }}
-The {{tt|std::stack}} class is a container adapter that gives the programmer the functionality of a stack - specifically, a FILO (first-in, last-out) data structure.
+The {{tt|std::stack}} class is a [[cpp/container#Container adaptors|container adaptor]] that gives the programmer the functionality of a {{enwiki|Stack (abstract data type)|stack}} - specifically, a LIFO (last-in, first-out) data structure.
-The underlying container type {{tt|Container}} must implement the following functions:
+The class template acts as a wrapper to the underlying container - only a specific set of functions is provided. The stack pushes and pops the element from the back of the underlying container, known as the top of the stack.
-* {{tt|back()}}
+===Template parameters===
-* {{tt|push_back()}}
+{{par begin}}
-* {{tt|pop_back()}}
+{{par|T|The type of the stored elements. The program is ill-formed if {{tt|T}} is not the same type as {{tt|Container::value_type}}.}}
+{{par|Container|The type of the underlying container to use to store the elements. The container must satisfy the requirements of {{named req|SequenceContainer}}. Additionally, it must provide the following functions with the [[cpp/named req/SequenceContainer#Optional operations|usual semantics]]:
+* {{tt|back()}}, e.g., {{lc|std::vector::back()}},
+* {{tt|push_back()}}, e.g., {{lc|std::deque::push_back()}},
+* {{tt|pop_back()}}, e.g., {{lc|std::list::pop_back()}}.
-The standard containers {{tt|std::vector}}, {{tt|std::deque}} and {{tt|std::list}} can be used.
+The standard containers {{lc|std::vector}} (including {{ltt|cpp/container/vector_bool|std::vector<bool>}}), {{lc|std::deque}} and {{lc|std::list}} satisfy these requirements.  By default, if no container class is specified for a particular stack class instantiation, the standard container {{lc|std::deque}} is used.
+}}{{par end}}
 ===Member types===
-{{dcl list begin}}
+{{dsc begin}}
-{{dcl list hitem | Member type | Definition}}
+{{dsc hitem|Type|Definition}}
-{{dcl list template | cpp/container/dcl list container_type | stack}}
+{{dsc inc|cpp/container/dsc container_type|stack}}
-{{dcl list template | cpp/container/dcl list value_type | stack}}
+{{dsc inc|cpp/container/dsc value_type|stack}}
-{{dcl list template | cpp/container/dcl list size_type | stack}}
+{{dsc inc|cpp/container/dsc size_type|stack}}
-{{dcl list template | cpp/container/dcl list reference | stack}}
+{{dsc inc|cpp/container/dsc reference|stack}}
-{{dcl list template | cpp/container/dcl list const_reference | stack}}
+{{dsc inc|cpp/container/dsc const_reference|stack}}
-{{dcl list end}}
+{{dsc end}}
+===Member objects===
+{{dsc begin}}
+{{dsc hitem|Member|Description}}
+{{dsc inc|cpp/container/dsc c|stack}}
+{{dsc end}}
 ===Member functions===
-{{dcl list begin}}
+{{dsc begin}}
-{{dcl list template | cpp/container/dcl list constructor | stack}}
+{{dsc inc|cpp/container/dsc constructor|stack}}
-{{dcl list template | cpp/container/dcl list destructor | stack}}
+{{dsc inc|cpp/container/dsc destructor|stack}}
-{{dcl list template | cpp/container/dcl list operator{{=}} | stack}}
+{{dsc inc|cpp/container/dsc operator{{=}}|stack}}
-{{dcl list h2 | Element access}}
+{{dsc h2|Element access}}
-{{dcl list template | cpp/container/dcl list top | stack}}
+{{dsc inc|cpp/container/dsc top|stack}}
-{{dcl list h2 | Capacity}}
+{{dsc h2|Capacity}}
-{{dcl list template | cpp/container/dcl list empty | stack}}
+{{dsc inc|cpp/container/dsc empty|stack}}
-{{dcl list template | cpp/container/dcl list size | stack}}
+{{dsc inc|cpp/container/dsc size|stack}}
-{{dcl list h2 | Modifiers}}
+{{dsc h2|Modifiers}}
-{{dcl list template | cpp/container/dcl list push | stack}}
+{{dsc inc|cpp/container/dsc push|stack}}
-{{dcl list template | cpp/container/dcl list emplace | stack}}
+{{dsc inc|cpp/container/dsc push_range|stack}}
-{{dcl list template | cpp/container/dcl list pop | stack}}
+{{dsc inc|cpp/container/dsc emplace|stack}}
-{{dcl list template | cpp/container/dcl list swap | stack}}
+{{dsc inc|cpp/container/dsc pop|stack}}
+{{dsc inc|cpp/container/dsc swap|stack}}
-{{dcl list h1 | Member objects}}
+{{dsc end}}
-{{dcl list template | cpp/container/dcl list c | stack}}
-{{dcl list end}}
 ===Non-member functions===
-{{dcl list begin}}
+{{dsc begin}}
-{{dcl list template | cpp/container/dcl list operator_cmp | stack}}
+{{dsc inc|cpp/container/dsc operator_cmp|stack}}
-{{dcl list template | cpp/container/dcl list swap2 | stack}}
+{{dsc inc|cpp/container/dsc swap2|stack}}
-{{dcl list end}}
+{{dsc end}}
 ===Helper classes===
-{{dcl list begin}}
+{{dsc begin}}
-{{dcl list template | cpp/container/dcl list uses_allocator | stack}}
+{{dsc inc|cpp/container/dsc uses_allocator|stack}}
-{{dcl list end}}
+{{dsc inc|cpp/container/dsc adaptor_formatter|stack}}
+{{dsc end}}
+{{rrev|since=c++17|
+==={{rl|deduction guides|Deduction guides}}===
+}}
+===Notes===
+{{ftm begin|std=1|comment=1}}
+{{ftm|__cpp_lib_containers_ranges|value=202202L|std=C++23|Ranges construction and insertion for containers}}
+{{ftm end}}
+===Example===
+{{example
+|Comment
+|code=
+|output=
+}}
+===Defect reports===
+{{dr list begin}}
+{{dr list item|wg=lwg|dr=307|std=C++98|before={{tt|Container}} could not be {{tt|std::vector<bool>}}|after=allowed}}
+{{dr list item|wg=lwg|dr=2566|std=C++98|before=Missing the requirement for {{tt|Container::value_type}} |after=ill-formed if {{tt|T}} is not the same type as {{tt|Container::value_type}}}}
+{{dr list end}}
+===See also===
+{{dsc begin}}
+{{dsc inc|cpp/container/dsc vector}}
+{{dsc inc|cpp/container/dsc vector bool}}
+{{dsc inc|cpp/container/dsc deque}}
+{{dsc inc|cpp/container/dsc list}}
+{{dsc end}}
-[[cs:cpp/container/stack]]
+{{langlinks|cs|de|es|fr|it|ja|pl|pt|ru|tr|zh}}
-[[de:cpp/container/stack]]
-[[es:cpp/container/stack]]
-[[fr:cpp/container/stack]]
-[[it:cpp/container/stack]]
-[[ja:cpp/container/stack]]
-[[pl:cpp/container/stack]]
-[[pt:cpp/container/stack]]
-[[ru:cpp/container/stack]]
-[[tr:cpp/container/stack]]
-[[zh:cpp/container/stack]]

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Sequence
array (C++11)
vector
vector<bool>
inplace_vector (C++26)
deque
forward_list (C++11)
list
Associative
set
multiset
map
multimap
Unordered associative
unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)
Adaptors
stack
queue
priority_queue
flat_set (C++23)
flat_multiset (C++23)
flat_map (C++23)
flat_multimap (C++23)
Views
span (C++20)
mdspan (C++23)
Tables
Iterator invalidation
Member function table
Non-member function table

Member functions
stack::stack
stack::~stack
stack::operator=
Element access
stack::top
Capacity
stack::empty
stack::size
Modifiers
stack::push
stack::push_range (C++23)
stack::emplace (C++11)
stack::pop
stack::swap (C++11)
Non-member functions
swap(std::stack) (C++11)
operator==operator!=operator<operator>operator<=operator>=operator<=> (C++20)
Helper classes
uses_allocator<std::stack> (C++11)
formatter<std::stack> (C++23)
Deduction guides(C++17)

Type	Definition
`container_type`	`Container`[edit]
`value_type`	`Container::value_type`[edit]
`size_type`	Container::size_type[edit]
`reference`	`Container::reference`[edit]
`const_reference`	`Container::const_reference`[edit]

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/container/stack"

Latest revision as of 15:41, 1 November 2024

Contents

[edit] Template parameters

[edit] Member types

[edit] Member objects

[edit] Member functions

Element access

Capacity

Modifiers