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)
Deduktionshilfen(C++17)

 

Definiert in Header <list>
template<     class T,     class Allocator = std::allocator<T> > class list;	(1)
namespace pmr {     template< class T >     using list = std::list<T, std::pmr::polymorphic_allocator<T>>; }	(2)	(seit C++17)

std::list ist ein Container, der das Einfügen und Entfernen von Elementen von beliebiger Stelle im Container in konstanter Zeit unterstützt. Schneller zufälliger Zugriff wird nicht unterstützt. Er wird üblicherweise als doppelt verkettete Liste implementiert. Verglichen mit std::forward_list bietet dieser Container bidirektionale Iterationsfähigkeiten, ist aber weniger speichereffizient.

Das Hinzufügen, Entfernen und Verschieben von Elementen innerhalb der Liste oder über mehrere Listen hinweg macht die Iteratoren oder Referenzen nicht ungültig. Ein Iterator wird nur ungültig, wenn das entsprechende Element gelöscht wird.

std::list erfüllt die Anforderungen von Container, AllocatorAwareContainer, SequenceContainer und ReversibleContainer.

Alle Memberfunktionen von std::list sind constexpr: es ist möglich, std::list Objekte während der Auswertung eines konstanten Ausdrucks zu erstellen und zu verwenden. Allerdings können std::list Objekte im Allgemeinen nicht constexpr sein, da jeder dynamisch zugewiesene Speicher im selben konstanten Ausdruck freigegeben werden muss.

(seit C++26)

Template-Parameter

T	-	Der Typ der Elemente. T muss die Anforderungen von CopyConstructible erfüllen. T muss die Anforderungen von CopyAssignable erfüllen, wenn list::operator= oder list::assign mit T instanziiert wird. (bis C++11) Die auf die Elemente angewendeten Anforderungen hängen von den tatsächlichen Operationen ab, die auf dem Container ausgeführt werden. Im Allgemeinen muss der Elementtyp ein vollständiger Typ sein und die Anforderungen von Erasable erfüllen, aber viele Memberfunktionen stellen strengere Anforderungen. (seit C++11) (bis C++17) Die auf die Elemente angewendeten Anforderungen hängen von den tatsächlichen Operationen ab, die auf dem Container ausgeführt werden. Im Allgemeinen muss der Elementtyp die Anforderungen von Erasable erfüllen, aber viele Memberfunktionen stellen strengere Anforderungen. Dieser Container (aber nicht seine Member) kann mit einem unvollständigen Elementtyp instanziiert werden, wenn der Allokator die Komplettheitsanforderungen des Allokators erfüllt. Feature-Test-Makro Wert Std Feature __cpp_lib_incomplete_container_elements 201505L (C++17) Minimale Unterstützung für unvollständige Typen (seit C++17)
Allocator	-	Ein Allokator, der zum Erwerb/Freigeben von Speicher und zum Erstellen/Zerstören der Elemente in diesem Speicher verwendet wird. Der Typ muss die Anforderungen von Allocator erfüllen. Das Verhalten ist undefiniert(bis C++20)Das Programm ist ill-formed(seit C++20), wenn Allocator::value_type nicht mit T übereinstimmt.

Member-Typen

Mitgliedertyp	Definition
value_type	T
allocator_type	Allocator
size_type	Vorzeichenloser Ganzzahltyp (normalerweise std::size_t)
difference_type	Vorzeichenbehafteter Ganzzahltyp (normalerweise std::ptrdiff_t)
Referenz	value_type&
const_reference	const value_type&
Zeiger	Allocator::pointer (bis C++11) std::allocator_traits<Allocator>::pointer (seit C++11)
const_pointer	Allocator::const_pointer (bis C++11) std::allocator_traits<Allocator>::const_pointer (seit C++11)
iterator	LegacyBidirectionalIterator und ConstexprIterator(seit C++26) zu value_type
const_iterator	LegacyBidirectionalIterator und ConstexprIterator(seit C++26) zu const value_type
reverse_iterator	std::reverse_iterator<iterator>
const_reverse_iterator	std::reverse_iterator<const_iterator>

Member-Funktionen

(Konstruktor)	konstruiert die list (public member function)
(Destruktor)	zerstört die list (public member function)
operator=	weist dem Container Werte zu (public member function)
assign	weist dem Container Werte zu (public member function)
assign_range (C++23)	weist dem Container einen Bereich von Werten zu (public member function)
get_allocator	gibt den zugehörigen Allocator zurück (public member function)
Elementzugriff
front	Greift auf das erste Element zu (public member function)
back	Greift auf das letzte Element zu (public member function)
Iteratoren
begincbegin (C++11)	gibt einen Iterator zum Anfang zurück (public member function)
endcend (C++11)	gibt einen Iterator zum Ende zurück (public member function)
rbegincrbegin (C++11)	gibt einen Reverse-Iterator zum Anfang zurück (public member function)
rendcrend (C++11)	gibt einen Reverse-Iterator zum Ende zurück (public member function)
Kapazität
empty	prüft, ob der Container leer ist (public member function)
size	Gibt die Anzahl der Elemente zurück (public member function)
max_size	Gibt die maximal mögliche Anzahl von Elementen zurück (public member function)
Modifizierer
clear	leert den Inhalt (public member function)
insert	fügt Elemente ein (public member function)
insert_range (C++23)	fügt einen Bereich von Elementen ein (public member function)
emplace (C++11)	konstruiert Elemente direkt (in-place) (public member function)
erase	entfernt Elemente (public member function)
push_back	fügt ein Element am Ende hinzu (public member function)
emplace_back (C++11)	konstruiert ein Element direkt (in-place) am Ende (public member function)
append_range (C++23)	fügt einen Bereich von Elementen am Ende hinzu (public member function)
pop_back	entfernt das letzte Element (public member function)
push_front	fügt ein Element am Anfang ein (public member function)
emplace_front (C++11)	konstruiert ein Element im-place am Anfang (public member function)
prepend_range (C++23)	fügt einen Elementbereich am Anfang hinzu (public member function)
pop_front	entfernt das erste Element (public member function)
resize	ändert die Anzahl der gespeicherten Elemente (public member function)
swap	tauscht die Inhalte (public member function)
Operationen
merge	fügt zwei sortierte Listen zusammen (public member function)
splice	verschiebt Elemente aus einer anderen list (public member function)
removeremove_if	entfernt Elemente, die bestimmte Kriterien erfüllen (public member function)
reverse	kehrt die Reihenfolge der Elemente um (public member function)
unique	entfernt aufeinanderfolgende doppelte Elemente (public member function)
sort	sortiert die Elemente (public member function)

Nicht-Member-Funktionen

operator==operator!=operator<operator<=operator>operator>=operator<=> (entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)	vergleicht die Werte von zwei lists lexikographisch (function template)
std::swap(std::list)	spezialisiert den Algorithmus std::swap (function template)
erase(std::list)erase_if(std::list) (C++20)	entfernt alle Elemente, die bestimmte Kriterien erfüllen (function template)

Deduction Guides

(seit C++17)

Anmerkungen

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_containers_ranges	202202L	(C++23)	Bereichskonstruktion und -einfügung für Container
__cpp_lib_constexpr_containers	202502L	(C++26)	constexpr std::list

Beispiel

Führen Sie diesen Code aus

#include <algorithm>
#include <iostream>
#include <list>
 
int main()
{
    // Create a list containing integers
    std::list<int> l = {7, 5, 16, 8};
 
    // Add an integer to the front of the list
    l.push_front(25);
    // Add an integer to the back of the list
    l.push_back(13);
 
    // Insert an integer before 16 by searching
    auto it = std::find(l.begin(), l.end(), 16);
    if (it != l.end())
        l.insert(it, 42);
 
    // Print out the list
    std::cout << "l = { ";
    for (int n : l)
        std::cout << n << ", ";
    std::cout << "};\n";
}

Ausgabe

l = { 25, 7, 5, 42, 16, 8, 13, };

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
LWG 230	C++98	T musste nicht CopyConstructible sein (ein Element vom Typ T konnte möglicherweise nicht konstruiert werden)	T muss auch CopyConstructible sein
LWG 276	C++98	T war immer erforderlich, um CopyAssignable zu sein	nur erforderlich, wenn operator= oder assign mit T instanziiert wird

Siehe auch

forward_list (C++11)

Einfach verkettete Liste (Klassenvorlage)