Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::stack
stack ( ) : stack ( Container ( ) ) { }
(1) (desde C++11)
(2)
explicit stack ( const Container & cont = Container ( ) ) ;
(hasta C++11)
explicit stack ( const Container & cont ) ;
(desde C++11)
explicit stack ( Container && cont ) ;
(3) (desde C++11)
stack ( const stack & other ) ;
(4) (declarado implícitamente)
stack ( stack && other ) ;
(5) (desde C++11)
(declarado implícitamente)
template < class InputIt >
stack ( InputIt first, InputIt last ) ;
(6) (desde C++23)
template < class Alloc >
explicit stack ( const Alloc & alloc ) ;
(7) (desde C++11)
template < class Alloc >
stack ( const Container & cont, const Alloc & alloc ) ;
(8) (desde C++11)
template < class Alloc >
stack ( Container && cont, const Alloc & alloc ) ;
(9) (desde C++11)
template < class Alloc >
stack ( const stack & other, const Alloc & alloc ) ;
(10) (desde C++11)
template < class Alloc >
stack ( stack && other, const Alloc & alloc ) ;
(11) (desde C++11)
template < class InputIt, class Alloc >
stack ( InputIt first, InputIt last, const Alloc & alloc ) ;
(12) (desde C++23)
template < container-compatible-range < T > R >
stack ( std:: from_range_t , R && rg ) ;
(13) (desde C++23)
template < container-compatible-range < T > R, class Alloc >
stack ( std:: from_range_t , R && rg, const Alloc & alloc ) ;
(14) (desde C++23)

Construye un nuevo contenedor subyacente del adaptador de contenedor a partir de diversas fuentes de datos.

1) Constructor por defecto. Inicializa el contenedor por valor.
2) Construye por copia el contenedor subyacente c con los contenidos de cont . Este es también el constructor por defecto. (until C++11)
3) Construye por movimiento el contenedor subyacente c con std :: move ( cont ) .
4) Constructor de copia . El adaptador se construye por copia con el contenido de other. c .
5) Constructor de movimiento . El adaptador se construye con std :: move ( other. c ) .
6) Construye el contenedor subyacente c con el contenido del rango [ first , last ) . Esta sobrecarga participa en la resolución de sobrecarga solo si InputIt satisface LegacyInputIterator .
7-12) Estos constructores participan en la resolución de sobrecarga solo si std:: uses_allocator < Container, Alloc > :: value es true , es decir, si el contenedor subyacente es un contenedor consciente del asignador (verdadero para todos los contenedores de la biblioteca estándar que pueden usarse con stack ).
7) Construye el contenedor subyacente utilizando alloc como asignador, como si fuera mediante c ( alloc ) .
8) Construye el contenedor subyacente con el contenido de cont y utilizando alloc como asignador, como si fuera mediante c ( cont, alloc ) .
9) Construye el contenedor subyacente con el contenido de cont utilizando semántica de movimiento mientras emplea alloc como asignador, como si fuera mediante c ( std :: move ( cont ) , alloc ) .
10) Construye el adaptador con los contenidos de other. c y utilizando alloc como asignador, como si fuera mediante c ( other. c , alloc ) .
11) Construye el adaptador con los contenidos de other usando semántica de movimiento mientras utiliza alloc como asignador, como si fuera c ( std :: move ( other. c ) , alloc ) .
12) Construye el contenedor subyacente con el contenido del rango [ first , last ) usando alloc como asignador, como si fuera mediante c ( first, last, alloc ) . Esta sobrecarga participa en la resolución de sobrecarga solo si InputIt satisface LegacyInputIterator .
13) Construye el contenedor subyacente con ranges:: to < Container > ( std:: forward < R > ( rg ) ) .
14) Construye el contenedor subyacente con ranges:: to < Container > ( std:: forward < R > ( rg ) , alloc ) .

Contenidos

Parámetros

alloc - asignador a utilizar para todas las asignaciones de memoria del contenedor subyacente
other - otro adaptador de contenedor que se utilizará como fuente para inicializar el contenedor subyacente
cont - contenedor que se utilizará como fuente para inicializar el contenedor subyacente
first, last - el par de iteradores que define el rango fuente de elementos con el que inicializar
rg - un rango compatible con contenedor , es decir, un input_range cuyos elementos son convertibles a T
Requisitos de tipo
-
Alloc debe cumplir con los requisitos de Allocator .
-
Container debe cumplir con los requisitos de Container . Los constructores que toman un parámetro de asignador participan en la resolución de sobrecarga solo si Container cumple con los requisitos de AllocatorAwareContainer .
-
InputIt debe cumplir con los requisitos de LegacyInputIterator .

Complejidad

Igual que la operación correspondiente en el contenedor encapsulado.

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_adaptor_iterator_pair_constructor 202106L (C++23) Constructores de pares de iteradores para std::queue y std::stack ; sobrecargas ( 6 ) y ( 12 )
__cpp_lib_containers_ranges 202202L (C++23) Construcción e inserción conscientes de rangos; sobrecargas ( 13 ) y ( 14 )

Ejemplo

Ejecutar este código 
#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); // sobrecarga (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, sobrecarga (13)
    auto c5 = std::stack(std::from_range_t, std::ranges::iota(0, 42));
    assert(c5.size() == 42);
    // mismo efecto con sintaxis de tubería, internamente usa sobrecarga (13)
    auto c6 = std::ranges::iota(0, 42) | std::ranges::to<std::stack>();
    assert(c6.size() == 42);
    std::allocator<int> alloc;
    // C++23, sobrecarga (14)
    auto c7 = std::stack(std::from_range_t, std::ranges::iota(0, 42), alloc);
    assert(c7.size() == 42);
    // mismo efecto con sintaxis de tubería, internamente usa sobrecarga (14)
    auto c8 = std::ranges::iota(0, 42) | std::ranges::to<std::stack>(alloc);
    assert(c8.size() == 42);
# endif
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
P0935R0 C++11 el constructor por defecto era explícito hecho implícito

Véase también

asigna valores al adaptador de contenedor
(función miembro pública)