Deduktionshilfen für std::queue

 

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::queue

Memberfunktionen

queue::queue

queue::~queue

queue::operator=

Elementzugriff

queue::front

queue::back

Kapazität

queue::empty

queue::size

Modifizierer

queue::push

queue::push_range (C++23)

queue::emplace (C++11)

queue::pop

queue::swap (C++11)

Nicht-Member-Funktionen

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

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

Hilfsklassen

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

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

Ableitungs-Guides(C++17)

 

Definiert in Header <queue>
template< class Container > queue( Container )     -> queue<typename Container::value_type, Container>;	(1)	(seit C++17)
template< class Container, class Alloc > queue( Container, Alloc )     -> queue<typename Container::value_type, Container>;	(2)	(seit C++17)
template< class InputIt > queue( InputIt, InputIt )     -> queue<typename std::iterator_traits<InputIt>::value_type>;	(3)	(seit C++23)
template< class InputIt, class Alloc > queue( InputIt, InputIt, Alloc )     -> queue<typename std::iterator_traits<InputIt>::value_type,        std::deque<typename std::iterator_traits<InputIt>::value_type, Alloc>>;	(4)	(seit C++23)
template< ranges::input_range R > queue( std::from_range_t, R&& )     -> queue<ranges::range_value_t<R>>;	(5)	(seit C++23)
template< ranges::input_range R, class Allocator > queue( std::from_range_t, R&&, Allocator )     -> queue<ranges::range_value_t<R>,        std::deque<ranges::range_value_t<R>, Allocator>>;	(6)	(seit C++23)

Diese Deduktionshilfen werden für queue bereitgestellt, um die Deduktion vom zugrunde liegenden Containertyp zu ermöglichen.

1) Deduziert den zugrunde liegenden Containertyp aus dem Argument.

2) Gleich wie (1), mit der Ausnahme, dass der Allokator bereitgestellt wird.

3) Deduziert den Elementtyp aus dem Iterator, unter Verwendung von std::deque<typename std::iterator_traits<InputIt>::value_type> als zugrunde liegenden Containertyp.

4) Gleich wie (3), mit der Ausnahme, dass der Allokator bereitgestellt wird.

5) Deduziert den Elementtyp aus einem std::from_range_t Tag und einem input_range.

6) Gleich wie (5), mit der Ausnahme, dass der Allokator bereitgestellt wird.

Diese Überladungen nehmen nur an der Auflösung von Überladungen teil, wenn

• InputIt (falls vorhanden) erfüllt LegacyInputIterator,
• Container (falls vorhanden) erfüllt Allocator nicht,
• für (3)(bis C++23)(4)(seit C++23), erfüllt Alloc Allocator, und
• std::uses_allocator_v<Container, Alloc> ist true, wenn sowohl Container als auch Alloc vorhanden sind.

Hinweis: In welchem Umfang die Bibliothek feststellt, dass ein Typ LegacyInputIterator nicht erfüllt, ist nicht spezifiziert, außer dass ganzzahlige Typen als Minimum keine Eingabeiteratoren qualifizieren. Ebenso ist der Umfang, in dem festgestellt wird, dass ein Typ Allocator nicht erfüllt, nicht spezifiziert, außer dass als Minimum der Mitgliedstyp Alloc::value_type existieren muss und der Ausdruck std::declval<Alloc&>().allocate(std::size_t{}) wohlgeformt sein muss, wenn er als nicht ausgewerteter Operand behandelt wird.

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 (2) und (4)
__cpp_lib_containers_ranges	202202L	(C++23)	Bereichs-fähige (Ranges-aware) Konstruktion und Einfügung; Überladungen (5) und (6)

Beispiel

Führen Sie diesen Code aus

#include <queue>
#include <vector>
 
int main()
{
    std::vector<int> v = {1, 2, 3, 4};
    std::queue s{v}; // guide #1 deduces std::queue<int, vector<int>>
}