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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::stack

Memberfunktionen

stack::stack

stack::~stack

stack::operator=

Elementzugriff

stack::top

Kapazität

stack::empty

stack::size

Modifizierer

stack::push

stack::push_range (C++23)

stack::emplace (C++11)

stack::pop

stack::swap (C++11)

Nicht-Member-Funktionen

swap(std::stack) (C++11)

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

Hilfsklassen

uses_allocator<std::stack> (C++11)

formatter<std::stack> (C++23)

Deduktionshilfen(C++17)

 

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

Konstruiert einen neuen zugrundeliegenden Container des Container-Adapters aus verschiedenen Datenquellen.

1) Standardkonstruktor. Wertinitialisiert den Container.

2) Kopiert den zugrundeliegenden Container c mit dem Inhalt von cont. Dies ist auch der Standardkonstruktor.(bis C++11)

3) Verschiebt den zugrundeliegenden Container c mit std::move(cont).

4) Kopierkonstruktor. Der Adapter wird mit dem Inhalt von other.c kopiert.

5) Verschiebekonstruktor. Der Adapter wird mit std::move(other.c) konstruiert.

6) Konstruiert den zugrundeliegenden Container mit dem Inhalt des Bereichs [first, last). Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn InputIt die Anforderungen von LegacyInputIterator erfüllt.

7-12) Diese Konstruktoren nehmen nur an der Überladungsauflösung teil, wenn std::uses_allocator<Container, Alloc>::value true ist, d. h. wenn der zugrundeliegende Container ein allokatorbewusster Container ist (wahr für alle Standardbibliothekscontainer, die mit stack verwendet werden können).

7) Konstruiert den zugrundeliegenden Container unter Verwendung von alloc als Allokator, als ob durch c(alloc).

8) Konstruiert den zugrundeliegenden Container mit dem Inhalt von cont und unter Verwendung von alloc als Allokator, als ob durch c(cont, alloc).

9) Konstruiert den zugrundeliegenden Container mit dem Inhalt von cont unter Verwendung von Move-Semantik und nutzt dabei alloc als Allokator, als ob durch c(std::move(cont), alloc).

10) Konstruiert den Adapter mit dem Inhalt von other.c und unter Verwendung von alloc als Allokator, als ob durch c(other.c, alloc).

11) Konstruiert den Adapter mit dem Inhalt von other unter Verwendung von Move-Semantik und nutzt dabei alloc als Allokator, als ob durch c(std::move(other.c), alloc).

12) Konstruiert den zugrundeliegenden Container mit dem Inhalt des Bereichs [first, last) unter Verwendung von alloc als Allokator, als ob durch c(first, last, alloc). Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn InputIt die Anforderungen von LegacyInputIterator erfüllt.

13) Konstruiert den zugrundeliegenden Container mit ranges::to<Container>(std::forward<R>(rg)).

14) Konstruiert den zugrundeliegenden Container mit ranges::to<Container>(std::forward<R>(rg), alloc).

Parameter

alloc	-	Allokator, der für alle Speicherallokationen des zugrundeliegenden Containers verwendet wird
Sonstiges	-	Ein weiterer Container-Adapter, der als Quelle zur Initialisierung des zugrundeliegenden Containers dient
cont	-	Container, der als Quelle zur Initialisierung des zugrundeliegenden Containers dient
first, last	-	Das Iteratorenpaar, das den Quellbereich der zu initialisierenden Elemente definiert
rg	-	Ein Container-kompatibler Bereich, d. h. ein input_range, dessen Elemente in T konvertierbar sind
Typanforderungen
- Alloc muss die Anforderungen von Allocator erfüllen.
- Container muss die Anforderungen von Container erfüllen. Die Konstruktoren, die einen Allokatorparameter nehmen, nehmen nur an der Überladungsauflösung teil, wenn Container die Anforderungen von AllocatorAwareContainer erfüllt.
- InputIt muss die Anforderungen von LegacyInputIterator erfüllen.

Komplexität

Gleich der entsprechenden Operation des umschlossenen Containers.

Hinweise

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_adaptor_iterator_pair_constructor	202106L	(C++23)	Iterator-Paar-Konstruktoren für std::queue und std::stack; Überladungen (6) und (12)
__cpp_lib_containers_ranges	202202L	(C++23)	Bereichsfreundlicher Konstruktor und Einfügen; Überladungen (13) und (14)

Beispiel

Führen Sie diesen Code aus

#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); // overload (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, overload (13)
    auto c5 = std::stack(std::from_range_t, std::ranges::iota(0, 42));
    assert(c5.size() == 42);
 
    // the same effect with pipe syntax, internally uses overload (13)
    auto c6 = std::ranges::iota(0, 42) | std::ranges::to<std::stack>();
    assert(c6.size() == 42);
 
    std::allocator<int> alloc;
 
    // C++23, overload (14)
    auto c7 = std::stack(std::from_range_t, std::ranges::iota(0, 42), alloc);
    assert(c7.size() == 42);
 
    // the same effect with pipe syntax, internally uses overload (14)
    auto c8 = std::ranges::iota(0, 42) | std::ranges::to<std::stack>(alloc);
    assert(c8.size() == 42);
# endif
}

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
P0935R0	C++11	Standardkonstruktor war explizit	wurde implizit gemacht

Siehe auch

operator=

weist Werte dem Container-Adapter zu (public member function)