deduction guides for std::stack

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de contenedores

De secuencias

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

deque

forward_list (C++11)

list

Asociativos

set

multiset

map

multimap

Asociativos no ordenados

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptadores

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Vistas

span (C++20)

mdspan (C++23)

Tablas

Invalidación de iteradores

Tabla de funciones miembro

Tabla de funciones no miembro

 

std::stack

Funciones miembro

stack::stack

stack::~stack

stack::operator=

Acceso a elementos

stack::top

Capacidad

stack::empty

stack::size

Modificadores

stack::push

stack::emplace (C++11)

stack::pop

stack::swap (C++11)

Funciones no miembro

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

std::swap (C++11)

Guías de deducción(C++17)

 

Definido en el archivo de encabezado <stack>
template<class Container> stack(Container)   -> stack<typename Container::value_type, Container>;	(1)	(desde C++17)
template<class InputIt> stack(InputIt, InputIt)   -> stack</*valor-de-iter-t*/<InputIt>>;	(2)	(desde C++23)
template<class Container, class Alloc> stack(Container, Alloc)   -> stack<typename Container::value_type, Container>;	(3)	(desde C++17)
template<class InputIt, class Alloc> stack(InputIt, InputIt, Alloc)   -> stack</*valor-de-iter-t*/<InputIt>,     std::deque</*valor-de-iter-t*/<InputIt>, Alloc>>;	(4)	(desde C++23)

Estas guías de deducción se proporcionan por stack para permitir la deducción a partir del tipo de contenedor subyacente.

1) Deduce el tipo de contenedor subyacente a partir del argumento.

2) Deduce el tipo de elemento a partir del iterador, usando std::deque</*valor-de-iter-t*/<InputIt>> como el tipo de contenedor subyacente, donde /*valor-de-iter-t*/<InputIt> denota typenamestd::iterator_traits<InputIt>::value_type.

3-4) Igual que (1-2), excepto que se proporciona un asignador de memoria.

Estas sobrecargas solo participan en la resolución de sobrecargas si

• InputIt (si existe) satisface InputIterator,
• Container (si existe) no satisface Allocator,
• Para (3)(hasta C++23)(4)(desde C++23), Alloc satisface Allocator, y
• std::uses_allocator_v<Container, Alloc> es true si tanto Container como Alloc existen.

Nota: no se especifica hasta qué grado la biblioteca determina que un tipo no satisface a IteradorDeEntradaLegado, excepto que, como mínimo, los tipos enteros no califican como iteradores de entrada. Del mismo modo, no se especifica en qué medida se determina que un tipo no satisface a Allocator, excepto que, como mínimo, el tipo miembro Alloc::value_type debe existir y la expresión std::declval<Alloc &>().allocate(std::size_t{}) debe estar bien formada cuando se trate como un operando no evaluado.

Ejemplo

Ejecuta este código

#include <vector>#include <stack>int main(){std::vector<int> v ={1, 2, 3, 4};std::stack s{v};// guía #1 deduce std::stack<int, vector<int>>}