Deduktionshilfen für std::list

 

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

Memberfunktionen
list::list list::~list list::operator= list::assign list::assign_range (C++23)   list::get_allocator Elementzugriff list::front list::back Iteratoren list::beginlist::cbegin (C++11) list::endlist::cend (C++11) list::rbeginlist::crbegin (C++11) list::rendlist::crend (C++11) Kapazität list::size list::empty list::max_size	Modifizierer list::clear list::insert list::insert_range (C++23) list::emplace (C++11) list::erase list::push_front list::emplace_front (C++11) list::prepend_range (C++23) list::pop_front list::push_back list::emplace_back (C++11) list::append_range (C++23) list::pop_back list::resize list::swap Operationen list::merge list::splice list::removelist::remove_if list::reverse list::unique list::sort
Nicht-Member-Funktionen
operator==operator<=> (C++20) swap(std::list) erase(std::list)erase_if(std::list) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Ableitungs-Guides(C++17)

 

Definiert in Header <list>
template< class InputIt,           class Alloc = std::allocator<               typename std::iterator_traits<InputIt>::value_type> > list( InputIt, InputIt, Alloc = Alloc() )     -> list<typename std::iterator_traits<InputIt>::value_type, Alloc>;	(1)	(seit C++17)
template< ranges::input_range R,           class Alloc = std::allocator<ranges::range_value_t<R>> > list( std::from_range_t, R&&, Alloc = Alloc() )     -> list<ranges::range_value_t<R>, Alloc>;	(2)	(seit C++23)

1) Diese Deduktionshilfe wird für list bereitgestellt, um die Deduktion aus einem Iterator-Bereich zu ermöglichen. Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn InputIt LegacyInputIterator erfüllt und Alloc Allocator erfüllt.

2) Diese Deduktionshilfe wird für list bereitgestellt, um die Deduktion aus einem std::from_range_t-Tag und einem input_range zu ermöglichen.

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

Anmerkungen

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_containers_ranges	202202L	(C++23)	Bereichsbezogene Konstruktion und Einfügung; Überladung (2)

Beispiel

Führen Sie diesen Code aus

#include <list>
#include <vector>
 
int main()
{
    std::vector<int> v = {1, 2, 3, 4};
 
    // uses explicit deduction guide to deduce std::list<int>
    std::list x(v.begin(), v.end());
 
    // deduces std::list<std::vector<int>::iterator>
    // first phase of overload resolution for list-initialization selects the candidate
    // synthesized from the initializer-list constructor; second phase is not performed
    // and deduction guide has no effect
    std::list y{v.begin(), v.end()};
}