Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::stack
stack ( ) : stack ( Container ( ) ) { }
(1) (depuis C++11)
(2)
explicit stack ( const Container & cont = Container ( ) ) ;
(jusqu'à C++11)
explicit stack ( const Container & cont ) ;
(depuis C++11)
explicit stack ( Container && cont ) ;
(3) (depuis C++11)
stack ( const stack & other ) ;
(4) (déclaré implicitement)
stack ( stack && other ) ;
(5) (depuis C++11)
(déclaré implicitement)
template < class InputIt >
stack ( InputIt first, InputIt last ) ;
(6) (depuis C++23)
template < class Alloc >
explicit stack ( const Alloc & alloc ) ;
(7) (depuis C++11)
template < class Alloc >
stack ( const Container & cont, const Alloc & alloc ) ;
(8) (depuis C++11)
template < class Alloc >
stack ( Container && cont, const Alloc & alloc ) ;
(9) (depuis C++11)
template < class Alloc >
stack ( const stack & other, const Alloc & alloc ) ;
(10) (depuis C++11)
template < class Alloc >
stack ( stack && other, const Alloc & alloc ) ;
(11) (depuis C++11)
template < class InputIt, class Alloc >
stack ( InputIt first, InputIt last, const Alloc & alloc ) ;
(12) (depuis C++23)
template < container-compatible-range < T > R >
stack ( std:: from_range_t , R && rg ) ;
(13) (depuis C++23)
template < container-compatible-range < T > R, class Alloc >
stack ( std:: from_range_t , R && rg, const Alloc & alloc ) ;
(14) (depuis C++23)

Construit un nouveau conteneur sous-jacent de l'adaptateur de conteneur à partir de diverses sources de données.

1) Constructeur par défaut. Initialise le conteneur par valeur.
2) Constructeur par copie du conteneur sous-jacent c avec le contenu de cont . C'est également le constructeur par défaut. (jusqu'à C++11)
3) Constructeur par déplacement du conteneur sous-jacent c avec std :: move ( cont ) .
4) Constructeur de copie . L'adaptateur est copie-construit avec le contenu de other. c .
5) Constructeur de déplacement . L'adaptateur est construit avec std :: move ( other. c ) .
6) Construit le conteneur sous-jacent c avec le contenu de la plage [ first , last ) . Cette surcharge participe à la résolution de surcharge seulement si InputIt satisfait LegacyInputIterator .
7-12) Ces constructeurs participent à la résolution de surcharge seulement si std:: uses_allocator < Container, Alloc > :: value est true , c'est-à-dire si le conteneur sous-jacent est un conteneur sensible à l'allocateur (vrai pour tous les conteneurs de la bibliothèque standard qui peuvent être utilisés avec stack ).
7) Construit le conteneur sous-jacent en utilisant alloc comme allocateur, comme par c ( alloc ) .
8) Construit le conteneur sous-jacent avec le contenu de cont et en utilisant alloc comme allocateur, comme par c ( cont, alloc ) .
9) Construit le conteneur sous-jacent avec le contenu de cont en utilisant la sémantique de déplacement tout en utilisant alloc comme allocateur, comme par c ( std :: move ( cont ) , alloc ) .
10) Construit l'adaptateur avec le contenu de other. c et en utilisant alloc comme allocateur, comme par c ( other. c , alloc ) .
11) Construit l'adaptateur avec le contenu de other en utilisant la sémantique de déplacement tout en utilisant alloc comme allocateur, comme par c ( std :: move ( other. c ) , alloc ) .
12) Construit le conteneur sous-jacent avec le contenu de la plage [ first , last ) en utilisant alloc comme allocateur, comme par c ( first, last, alloc ) . Cette surcharge participe à la résolution de surcharge seulement si InputIt satisfait LegacyInputIterator .
13) Construit le conteneur sous-jacent avec ranges:: to < Container > ( std:: forward < R > ( rg ) ) .
14) Construit le conteneur sous-jacent avec ranges:: to < Container > ( std:: forward < R > ( rg ) , alloc ) .

Table des matières

Paramètres

alloc - allocateur à utiliser pour toutes les allocations mémoire du conteneur sous-jacent
other - un autre adaptateur de conteneur à utiliser comme source pour initialiser le conteneur sous-jacent
cont - conteneur à utiliser comme source pour initialiser le conteneur sous-jacent
first, last - la paire d'itérateurs définissant la plage source des éléments à initialiser
rg - une plage compatible avec les conteneurs , c'est-à-dire une input_range dont les éléments sont convertibles en T
Exigences de type
-
Alloc doit satisfaire aux exigences de Allocator .
-
Container doit satisfaire aux exigences de Container . Les constructeurs prenant un paramètre d'allocateur participent à la résolution de surcharge seulement si Container satisfait aux exigences de AllocatorAwareContainer .
-
InputIt doit satisfaire aux exigences de LegacyInputIterator .

Complexité

Identique à l'opération correspondante sur le conteneur encapsulé.

Notes

Macro de test de fonctionnalité Valeur Norme Fonctionnalité
__cpp_lib_adaptor_iterator_pair_constructor 202106L (C++23) Constructeurs de paires d'itérateurs pour std::queue et std::stack ; surcharges ( 6 ) et ( 12 )
__cpp_lib_containers_ranges 202202L (C++23) Construction et insertion compatibles avec les gammes ; surcharges ( 13 ) et ( 14 )

Exemple

Exécuter ce code 
#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); // surcharge (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, surcharge (13)
    auto c5 = std::stack(std::from_range_t, std::ranges::iota(0, 42));
    assert(c5.size() == 42);
    // même effet avec la syntaxe pipe, utilise en interne la surcharge (13)
    auto c6 = std::ranges::iota(0, 42) | std::ranges::to<std::stack>();
    assert(c6.size() == 42);
    std::allocator<int> alloc;
    // C++23, surcharge (14)
    auto c7 = std::stack(std::from_range_t, std::ranges::iota(0, 42), alloc);
    assert(c7.size() == 42);
    // même effet avec la syntaxe pipe, utilise en interne la surcharge (14)
    auto c8 = std::ranges::iota(0, 42) | std::ranges::to<std::stack>(alloc);
    assert(c8.size() == 42);
# endif
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
P0935R0 C++11 default constructor was explicit made implicit

Voir aussi

assigne des valeurs à l'adaptateur de conteneur
(fonction membre publique)