`list`-Klasse

Artikel
10/12/2023

Die C++-Standardbibliothekslistenklasse ist eine Klassenvorlage von Sequenzcontainern, die ihre Elemente in einer linearen Anordnung verwalten und effiziente Einfügungen und Löschungen an einer beliebigen Stelle innerhalb der Sequenz ermöglichen. Die Sequenz wird als bidirektionale verknüpfte Liste von Elementen gespeichert, die jeweils ein Element eines Typs Typeenthalten.

Syntax

template <class Type, class Allocator= allocator<Type>>
class list

Parameter

Type
Der in der Liste zu speichernde Elementdatentyp.

Allocator
Der Typ, der das gespeicherte Zuordnungsobjekt darstellt, das Details zum Belegen und Freigeben des Arbeitsspeichers der Liste kapselt. Dieses Argument ist optional, und der Standardwert ist allocator<Type>.

Hinweise

Die Auswahl des Containertyps sollte im Allgemeinen auf Grundlage des für die Anwendung erforderlichen Suchen und Einfügetyps erfolgen. Vektoren sollten der bevorzugte Container zum Verwalten einer Sequenz sein, wenn zufälliger Zugriff auf jedes Element unbedingt erforderlich und das Einfügen oder Löschen von Elementen nur am Ende einer Sequenz notwendig ist. Die Leistung des deque-Klassencontainers hat Vorrang, wenn zufälliger Zugriff erforderlich ist und Einfügungen und Löschungen sowohl am Anfang als auch am Ende einer Sequenz unbedingt notwendig sind.

Die Listenelementfunktionen merge, reverse, unique, removeund remove_if wurden für den Betrieb auf Listenobjekten optimiert und bieten eine leistungsstarke Alternative zu ihren generischen Gegenstücken.

Die Neuzuordnung von Listen tritt auf, wenn Elemente der Liste von einer Memberfunktion eingefügt oder gelöscht werden müssen. In solchen Fällen werden nur Iteratoren oder Verweise auf gelöschte Teile der gesteuerten Sequenz ungültig.

Schließen Sie den C++-Standardbibliotheksstandardheader <list> ein, um die container Klassenvorlagenliste und mehrere unterstützende Vorlagen zu definieren.

Member

Konstruktoren

Name	Beschreibung
`list`	Erstellt eine Liste einer bestimmten Größe bzw. mit Elementen eines bestimmten Werts oder mit einem bestimmten `allocator`-Element oder als vollständige bzw. teilweise Kopie einer anderen Liste.

TypeDefs

Name	Beschreibung
`allocator_type`	Ein Typ, mit dem die `allocator`-Klasse für ein Listenobjekt dargestellt wird.
`const_iterator`	Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem ein `const`-Element in einer Liste gelesen werden kann.
`const_pointer`	Ein Typ, der einen Zeiger auf ein `const`-Element in einer Liste bereitstellt.
`const_reference`	Ein Typ, der einen Verweis auf ein `const`-Element bereitstellt, das in einer Liste zum Lesen und Ausführen von `const`-Vorgängen gespeichert ist.
`const_reverse_iterator`	Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem jedes beliebige `const`-Element in einer Liste gelesen werden kann.
`difference_type`	Ein Typ, der den Unterschied zwischen zwei Iteratoren, die auf Elemente innerhalb derselben Liste verweisen, bereitstellt.
`iterator`	Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem jedes Element in einer Liste gelesen oder geändert werden kann.
`pointer`	Ein Typ, der einen Zeiger auf ein Element in einer Liste bereitstellt.
`reference`	Ein Typ, der einen Verweis auf ein `const`-Element bereitstellt, das in einer Liste zum Lesen und Ausführen von `const`-Vorgängen gespeichert ist.
`reverse_iterator`	Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem ein Element in einer umgekehrten Liste gelesen oder geändert werden kann.
`size_type`	Ein Typ, der die Anzahl von Elementen in einer Liste zählt.
`value_type`	Ein Typ, der den in einer Liste gespeicherten Datentyp darstellt.

Functions

Name	Beschreibung
`assign`	Löscht Elemente aus einer Liste und kopiert einen neuen Satz von Elementen in die Zielliste.
`back`	Gibt einen Verweis auf das letzte Element einer Liste zurück.
`begin`	Gibt einen Iterator zurück, der das erste Element in einer Liste adressiert.
`cbegin`	Gibt einen konstanten Iterator zurück, der das erste Element in einer Liste adressiert.
`cend`	Gibt einen konstanten Iterator zurück, der den Speicherort adressiert, der dem letzten Element einer Liste nachfolgt.
`clear`	Löscht alle Elemente einer Liste.
`crbegin`	Gibt einen konstanten Iterator zurück, der das erste Element in einer umgekehrten Liste adressiert.
`crend`	Gibt einen konstanten Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines umgekehrten Listenelements nachfolgt.
`emplace`	Fügt ein direkt konstruiertes Element an einer angegebenen Position in die Liste ein.
`emplace_back`	Fügt ein direkt konstruiertes Element am Ende einer Liste ein.
`emplace_front`	Fügt ein direkt konstruiertes Element am Anfang einer Liste ein.
`empty`	Testet, ob eine Liste leer ist.
`end`	Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element einer Liste nachfolgt.
`erase`	Entfernt ein Element oder eine Reihe von Elementen in einer Liste aus angegebenen Speicherorten.
`front`	Gibt einen Verweis auf das erste Element in einer Liste zurück.
`get_allocator`	Gibt eine Kopie des `allocator`-Objekts zurück, das zum Erstellen einer Liste verwendet wird.
`insert`	Fügt ein Element oder mehrere Elemente oder ein Reihe von Elementen an einer bestimmten Position in die Liste ein.
`max_size`	Gibt die Maximallänge einer Liste zurück.
`merge`	Entfernt die Elemente aus der Argumentliste, fügt sie in die Zielliste ein und sortiert den neuen, kombinierten Elementsatz in aufsteigender Reihenfolge oder in einer anderen angegebenen Reihenfolge.
`pop_back`	Löscht das Element am Ende einer Liste.
`pop_front`	Löscht das Element am Anfang einer Liste.
`push_back`	Fügt am Ende einer Liste ein Element hinzu.
`push_front`	Fügt am Anfang einer Liste ein Element hinzu.
`rbegin`	Gibt einen Iterator zurück, der das erste Element in einer umgekehrten Liste adressiert.
`remove`	Löscht Elemente in einer Liste, die einen angegebenen Wert entsprechen.
`remove_if`	Löscht Elemente aus der Liste, für die ein angegebenes Prädikat erfüllt ist.
`rend`	Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element einer umgekehrten Liste nachfolgt.
`resize`	Gibt eine neue Größe für eine Liste an.
`reverse`	Kehrt die Reihenfolge um, in der die Elemente in einer Liste auftreten.
`size`	Gibt die Anzahl von Elementen in einer Liste zurück.
`sort`	Ordnet die Elemente einer Liste in aufsteigender Reihenfolge oder in Bezug auf eine andere Reihenfolgebeziehung.
`splice`	Entfernt Elemente aus der Argumentliste und fügt sie in die Zielliste ein.
`swap`	Tauscht die Elemente zweier Listen aus.
`unique`	Entfernt benachbarte doppelte Elemente oder benachbarte Elemente, die einige andere binäre Prädikate aus der Liste erfüllen.

Operatoren

Name	Beschreibung
`operator=`	Ersetzt die Elemente der Liste mit einer Kopie einer anderen Liste.

Anforderungen

Header: <list>

`allocator_type`

Ein Typ, mit dem die Zuweisungsklasse für ein Listenobjekt dargestellt wird.

typedef Allocator allocator_type;

Hinweise

allocator_type ist ein Synonym für den Vorlagenparameter Allocator.

Beispiel

Ein Beispiel hierfür finden Sie unter get_allocator.

`assign`

Löscht Elemente aus einer Liste und kopiert einen neuen Satz von Elementen in eine Zielliste.

void assign(
    size_type Count,
    const Type& Val);

void assign
    initializer_list<Type> IList);

template <class InputIterator>
void assign(
    InputIterator First,
    InputIterator Last);

Parameter

First
Die Position des ersten Elements in dem aus der Argumentliste zu kopierenden Elementbereich.

Last
Die Position des ersten Elements direkt hinter dem aus der Argumentliste zu kopierenden Elementbereich.

Count
Die Anzahl von Kopien eines Elements, das in die Liste eingefügt wird.

Val
Der Wert des Elements, das in die Liste eingefügt wird.

IList
Das initializer_list-Element, das die einzufügenden Elemente enthält.

Hinweise

Nachdem alle vorhandenen Elemente in der Zielliste gelöscht sind, wird entweder ein angegebener Elementbereich aus der ursprünglichen Liste oder aus einer anderen Liste in die Zielliste eingefügt, oder es werden Kopien eines neuen Elements eines angegebenen Werts in die Zielliste eingefügt.

Beispiel

// list_assign.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main()
{
    using namespace std;
    list<int> c1, c2;
    list<int>::const_iterator cIter;

    c1.push_back(10);
    c1.push_back(20);
    c1.push_back(30);
    c2.push_back(40);
    c2.push_back(50);
    c2.push_back(60);

    cout << "c1 =";
    for (auto c : c1)
        cout << " " << c;
    cout << endl;

    c1.assign(++c2.begin(), c2.end());
    cout << "c1 =";
    for (auto c : c1)
        cout << " " << c;
    cout << endl;

    c1.assign(7, 4);
    cout << "c1 =";
    for (auto c : c1)
        cout << " " << c;
    cout << endl;

    c1.assign({ 10, 20, 30, 40 });
    cout << "c1 =";
    for (auto c : c1)
        cout << " " << c;
    cout << endl;
}

c1 = 10 20 30c1 = 50 60c1 = 4 4 4 4 4 4 4c1 = 10 20 30 40

`back`

Gibt einen Verweis auf das letzte Element einer Liste zurück.

reference back();

const_reference back() const;

Rückgabewert

Das letzte Element der Liste. Wenn die Liste leer ist, ist der Rückgabewert nicht definiert.

Hinweise

Wenn back dem Rückgabewert von const_reference zugewiesen wird, kann das Listenobjekt nicht geändert werden. Wenn back dem Rückgabewert von reference zugewiesen wird, kann das Listenobjekt geändert werden.

Bei der Kompilierung mithilfe von _ITERATOR_DEBUG_LEVEL 1 oder 2 tritt ein Laufzeitfehler auf, wenn Sie versuchen, auf ein Element in einer leeren Liste zuzugreifen. Weitere Informationen finden Sie unter Checked Iterators .

Beispiel

// list_back.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

   int& i = c1.back( );
   const int& ii = c1.front( );

   cout << "The last integer of c1 is " << i << endl;
   i--;
   cout << "The next-to-last integer of c1 is " << ii << endl;
}

The last integer of c1 is 11
The next-to-last integer of c1 is 10

`begin`

Gibt einen Iterator zurück, der das erste Element in einer Liste adressiert.

const_iterator begin() const;

iterator begin();

Rückgabewert

Ein bidirektionaler Iterator, der das erste Element in der Liste adressiert oder auf den Speicherort hinweist, der auf eine leere Liste folgt.

Hinweise

Wenn der Rückgabewert begin eines const_iteratorObjekts zugewiesen ist, können die Elemente im Listenobjekt nicht geändert werden. Wenn der Rückgabewert begin eines iteratorObjekts zugewiesen ist, können die Elemente im Listenobjekt geändert werden.

Beispiel

// list_begin.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::iterator c1_Iter;
   list <int>::const_iterator c1_cIter;

   c1.push_back( 1 );
   c1.push_back( 2 );

   c1_Iter = c1.begin( );
   cout << "The first element of c1 is " << *c1_Iter << endl;

*c1_Iter = 20;
   c1_Iter = c1.begin( );
   cout << "The first element of c1 is now " << *c1_Iter << endl;

   // The following line would be an error because iterator is const
   // *c1_cIter = 200;
}

The first element of c1 is 1
The first element of c1 is now 20

`cbegin`

Gibt einen const-Iterator zurück, mit dem das erste Element im Bereich behandelt wird.

const_iterator cbegin() const;

Rückgabewert

Ein bidirektionaler const-Access-Iterator, der auf das erste Element des Bereichs zeigt oder auf die Position direkt hinter dem Ende eines leeren Bereichs (für einen leeren Bereich gilt cbegin() == cend()).

Hinweise

Bei dem Rückgabewert cbegin können die Elemente im Bereich nicht geändert werden.

Sie können diese Memberfunktion anstelle der begin()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. In der Regel wird sie zusammen mit dem auto Stichwort "Typabzug" verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der begin() und cbegin() unterstützt.

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

Gibt einen const-Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines Bereichs unmittelbar nachfolgt.

const_iterator cend() const;

Rückgabewert

Ein bidirektionaler const-Access-Iterator, der auf eine Position unmittelbar nach dem Ende des Bereichs verweist.

Hinweise

cend wird verwendet, um zu testen, ob ein Iterator das Ende seines Bereichs übergeben hat.

Sie können diese Memberfunktion anstelle der end()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. In der Regel wird sie zusammen mit dem auto Stichwort "Typabzug" verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der end() und cend() unterstützt.

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Der von cend zurückgegebene Wert darf nicht dereferenziert werden.

clear

Löscht alle Elemente einer Liste.

void clear();

Beispiel

// list_clear.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main() {
   using namespace std;
   list <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   cout << "The size of the list is initially " << c1.size( ) << endl;
   c1.clear( );
   cout << "The size of list after clearing is " << c1.size( ) << endl;
}

The size of the list is initially 3
The size of list after clearing is 0

`const_iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem ein const-Element in einer Liste gelesen werden kann.

typedef implementation-defined const_iterator;

Hinweise

Ein const_iterator-Typ kann nicht zum Ändern des Werts eines Elements verwendet werden.

Beispiel

Ein Beispiel hierfür finden Sie unter back.

`const_pointer`

Stellt einen Zeiger auf ein const-Element in einer Liste bereit.

typedef typename Allocator::const_pointer const_pointer;

Hinweise

Ein const_pointer-Typ kann nicht zum Ändern des Werts eines Elements verwendet werden.

In den meisten Fällen sollte ein iterator Element für den Zugriff auf die Elemente in einem Listenobjekt verwendet werden.

`const_reference`

Ein Typ, der einen Verweis auf ein const-Element bereitstellt, das in einer Liste zum Lesen und Ausführen von const-Vorgängen gespeichert ist.

typedef typename Allocator::const_reference const_reference;

Hinweise

Ein const_reference-Typ kann nicht zum Ändern des Werts eines Elements verwendet werden.

Beispiel

// list_const_ref.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const list <int> c2 = c1;
   const int &i = c2.front( );
   const int &j = c2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

   // The following line would cause an error because c2 is const
   // c2.push_back( 30 );
}

The first element is 10
The second element is 20

`const_reverse_iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem jedes beliebige const-Element in einer Liste gelesen werden kann.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Hinweise

Ein const_reverse_iterator-Typ kann nicht den Wert eines Elements ändern und wird verwendet, um die Liste in umgekehrter Reihenfolge zu durchlaufen.

Beispiel

Ein Beispiel hierfür finden Sie unter rbegin.

`crbegin`

Gibt einen konstanten Iterator zurück, der das erste Element in einer umgekehrten Liste adressiert.

const_reverse_iterator rbegin() const;

Rückgabewert

Ein umgekehrter bidirektionalem Iterator bezieht sich auf das erste Element in einer umgekehrten Liste (oder auf das ehemals letzte Element in der nicht umgekehrten Liste list).

Hinweise

crbegin wird mit einer umgekehrten Liste verwendet, genau wie list::begin bei einer list.

Bei dem Rückgabewert von crbegin kann das Listenobjekt nicht geändert werden. Mit list::rbegin kann eine Liste rückwärts durchlaufen werden.

Beispiel

// list_crbegin.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::const_reverse_iterator c1_crIter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1_crIter = c1.crbegin( );
   cout << "The last element in the list is " << *c1_crIter << "." << endl;
}

The last element in the list is 30.

`crend`

Gibt einen konstanten Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines umgekehrten Listenelements nachfolgt.

const_reverse_iterator rend() const;

Rückgabewert

Ein umgekehrter bidirektionaler Iterator, der die Position angibt, an der das letzte Element in einem umgekehrten list Element ausgeführt wurde (die Position, die dem ersten Element in der unreversierten listSeite vorausging).

Hinweise

crend wird mit einer umgekehrten Liste verwendet, genau wie list::end bei einer list.

Bei dem Rückgabewert von crend kann das list-Objekt nicht geändert werden.

crend kann verwendet werden, um zu testen, ob das Ende der list von einem umgekehrten Iterator erreicht wurde.

Der von crend zurückgegebene Wert darf nicht dereferenziert werden.

Beispiel

// list_crend.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::const_reverse_iterator c1_crIter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_crIter = c1.crend( );
   c1_crIter --;  // Decrementing a reverse iterator moves it forward in
                 // the list (to point to the first element here)
   cout << "The first element in the list is: " << *c1_crIter << endl;
}

The first element in the list is: 10

`difference_type`

Ein Ganzzahltyp mit Vorzeichen, der dazu verwendet werden kann, die Anzahl von Elementen einer Liste in einem Bereich zwischen Elementen darzustellen, auf die von Iteratoren gezeigt wird.

typedef typename Allocator::difference_type difference_type;

Hinweise

difference_type ist der Typ, der beim Subtrahieren oder Inkrementieren über Iteratoren des Containers zurückgegeben wird. difference_type wird normalerweise verwendet, um die Anzahl von Elementen im Bereich [ first, last) zwischen den Iteratoren first und last darzustellen. Dazu gehört das Element, auf das durch first gezeigt wird sowie der Bereich von Elementen bis zu (aber nicht einschließlich) dem Element, auf das durch last gezeigt wird.

Beachten Sie, dass zwar difference_type für alle Iteratoren verfügbar ist, die die Anforderungen eines Eingabe-Iterators erfüllen, die die Klasse bidirektionaler Iteratoren enthält, die von umkehrbaren Containern wie Set unterstützt werden, subtraktion zwischen Iteratoren wird jedoch nur von Iteratoren mit wahlfreiem Zugriff unterstützt, z vector . B. Class.

Beispiel

// list_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <list>
#include <algorithm>

int main( )
{
   using namespace std;

   list <int> c1;
   list <int>::iterator   c1_Iter, c2_Iter;

   c1.push_back( 30 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 10 );
   c1.push_back( 30 );
   c1.push_back( 20 );

   c1_Iter = c1.begin( );
   c2_Iter = c1.end( );

    list <int>::difference_type df_typ1, df_typ2, df_typ3;

   df_typ1 = count( c1_Iter, c2_Iter, 10 );
   df_typ2 = count( c1_Iter, c2_Iter, 20 );
   df_typ3 = count( c1_Iter, c2_Iter, 30 );
   cout << "The number '10' is in c1 collection " << df_typ1 << " times.\n";
   cout << "The number '20' is in c1 collection " << df_typ2 << " times.\n";
   cout << "The number '30' is in c1 collection " << df_typ3 << " times.\n";
}

The number '10' is in c1 collection 1 times.
The number '20' is in c1 collection 2 times.
The number '30' is in c1 collection 3 times.

`emplace`

Fügt ein direkt konstruiertes Element an einer angegebenen Position in die Liste ein.

void emplace(iterator Where, Type&& val);

Parameter

Where
Die Position im Ziel list , an der das erste Element eingefügt wird.

val
Das Element, das am Ende der list hinzugefügt wird.

Hinweise

Wenn eine Ausnahme ausgelöst wird, bleibt die list unverändert, und die Ausnahme wird erneut ausgelöst.

Beispiel

// list_emplace.cpp
// compile with: /EHsc
#include <list>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   list <string> c2;
   string str("a");

   c2.emplace(c2.begin(), move( str ) );
   cout << "Moved first element: " << c2.back( ) << endl;
}

Moved first element: a

`emplace_back`

Fügt ein direkt konstruiertes Element am Ende einer Liste ein.

void emplace_back(Type&& val);

Parameter

val
Das Element, das am Ende der list hinzugefügt wird.

Hinweise

Wenn eine Ausnahme ausgelöst wird, bleibt die list unverändert, und die Ausnahme wird erneut ausgelöst.

Beispiel

// list_emplace_back.cpp
// compile with: /EHsc
#include <list>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   list <string> c2;
   string str("a");

   c2.emplace_back( move( str ) );
   cout << "Moved first element: " << c2.back( ) << endl;
}

Moved first element: a

`emplace_front`

Fügt ein direkt konstruiertes Element am Anfang einer Liste ein.

void emplace_front(Type&& val);

Parameter

val
Das Element, das am Anfang der list.

Hinweise

Wenn eine Ausnahme ausgelöst wird, bleibt die list unverändert, und die Ausnahme wird erneut ausgelöst.

Beispiel

// list_emplace_front.cpp
// compile with: /EHsc
#include <list>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   list <string> c2;
   string str("a");

   c2.emplace_front( move( str ) );
   cout << "Moved first element: " << c2.front( ) << endl;
}

Moved first element: a

`empty`

Testet, ob eine Liste leer ist.

bool empty() const;

Rückgabewert

true wenn die Liste leer ist; false wenn die Liste nicht leer ist.

Beispiel

// list_empty.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;

   c1.push_back( 10 );
   if ( c1.empty( ) )
      cout << "The list is empty." << endl;
   else
      cout << "The list is not empty." << endl;
}

The list is not empty.

`end`

Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element einer Liste nachfolgt.

const_iterator end() const;
iterator end();

Rückgabewert

Ein bidirektionaler Iterator, der den Speicherort adressiert, der dem letzten Element einer Liste nachfolgt. Wenn die Liste leer ist, dann gilt list::end == list::begin.

Hinweise

end wird verwendet, um zu testen, ob ein Iterator das Ende seiner Liste erreicht hat.

Beispiel

// list_end.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::iterator c1_Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_Iter = c1.end( );
   c1_Iter--;
   cout << "The last integer of c1 is " << *c1_Iter << endl;

   c1_Iter--;
*c1_Iter = 400;
   cout << "The new next-to-last integer of c1 is "
        << *c1_Iter << endl;

   // If a const iterator had been declared instead with the line:
   // list <int>::const_iterator c1_Iter;
   // an error would have resulted when inserting the 400

   cout << "The list is now:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
}

The last integer of c1 is 30
The new next-to-last integer of c1 is 400
The list is now: 10 400 30

`erase`

Entfernt ein Element oder eine Reihe von Elementen in einer Liste aus angegebenen Speicherorten.

iterator erase(iterator Where);
iterator erase(iterator first, iterator last);

Parameter

Where
Die Position des von der Liste zu entfernenden Elements.

first
Die Position des ersten Elements, das von der Liste entfernt werden soll.

last
Die Position direkt hinter dem letzten von der Liste entfernten Element.

Rückgabewert

Ein bidirektionaler Iterator, der das erste über die entfernten Elemente hinaus verbliebene Element festlegt, oder ein Zeiger, der das Ende der Liste darstellt, wenn kein solches Element vorhanden ist

Hinweise

Es erfolgt keine Neuzuordnung. Die Iteratoren und Verweise werden nur für die gelöschten Elemente ungültig.

erase löst nie eine Ausnahme aus.

Beispiel

// list_erase.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::iterator Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 40 );
   c1.push_back( 50 );
   cout << "The initial list is:";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << " " << *Iter;
   cout << endl;

   c1.erase( c1.begin( ) );
   cout << "After erasing the first element, the list becomes:";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << " " << *Iter;
   cout << endl;
   Iter = c1.begin( );
   Iter++;
   c1.erase( Iter, c1.end( ) );
   cout << "After erasing all elements but the first, the list becomes: ";
   for (Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << " " << *Iter;
   cout << endl;
}

The initial list is: 10 20 30 40 50
After erasing the first element, the list becomes: 20 30 40 50
After erasing all elements but the first, the list becomes:  20

`front`

Gibt einen Verweis auf das erste Element in einer Liste zurück.

reference front();
const_reference front() const;

Rückgabewert

Wenn die Liste leer ist, ist die Rückgabe nicht definiert.

Hinweise

Wenn front dem Rückgabewert von const_reference zugewiesen wird, kann das Listenobjekt nicht geändert werden. Wenn front dem Rückgabewert von reference zugewiesen wird, kann das Listenobjekt geändert werden.

Beispiel

// list_front.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main() {
   using namespace std;
   list <int> c1;

   c1.push_back( 10 );

   int& i = c1.front();
   const int& ii = c1.front();

   cout << "The first integer of c1 is " << i << endl;
   i++;
   cout << "The first integer of c1 is " << ii << endl;
}

The first integer of c1 is 10
The first integer of c1 is 11

`get_allocator`

Gibt eine Kopie des Zuweisungsobjekts zurück, das zum Erstellen einer Liste verwendet wird.

Allocator get_allocator() const;

Rückgabewert

Die Zuweisung von der Liste verwendet.

Hinweise

Zuweisungen für die Listenklasse geben an, wie die Klasse einen Speicher verwaltet. Für die meisten Programmieranforderungen reichen die standardmäßigen allocator-Objekte mit Container-Klassen der C++-Standardbibliothek aus. Schreiben und Verwenden Ihrer eigener Zuweisungsklasse ist ein C++ -Thema für Fortgeschrittene.

Beispiel

// list_get_allocator.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects
   // that use the default allocator.
   list <int> c1;
   list <int, allocator<int> > c2 = list <int, allocator<int> >( allocator<int>( ) );

   // c3 will use the same allocator class as c1
   list <int> c3( c1.get_allocator( ) );

   list<int>::allocator_type xlst = c1.get_allocator( );
   // You can now call functions on the allocator class used by c1
}

`insert`

Fügt ein Element oder mehrere Elemente oder ein Reihe von Elementen an einer bestimmten Position in die Liste ein.

iterator insert(iterator Where, const Type& Val);
iterator insert(iterator Where, Type&& Val);

void insert(iterator Where, size_type Count, const Type& Val);
iterator insert(iterator Where, initializer_list<Type> IList);

template <class InputIterator>
void insert(iterator Where, InputIterator First, InputIterator Last);

Parameter

Where
Die Position in der Zielliste, an der das erste Element eingefügt wird.

Val
Der Wert des Elements, das in die Liste eingefügt wird.

Count
Die Anzahl von Elementen, die in die Liste eingefügt werden.

First
Die Position des ersten Elements in dem Elementbereich in der Argumentliste, die kopiert werden soll.

Last
Die Position des ersten Elements hinter dem Elementbereich in der Argumentliste, die kopiert werden soll.

Rückgabewert

Die ersten zwei Einfügefunktionen geben ein Iterator zurück, der auf den Speicherort zeigt, an dem das neue Element in die Liste eingefügt wurde.

Beispiel

// list_class_insert.cpp
// compile with: /EHsc
#include <list>
#include <iostream>
#include <string>

int main()
{
    using namespace std;
    list <int> c1, c2;
    list <int>::iterator Iter;

    c1.push_back(10);
    c1.push_back(20);
    c1.push_back(30);
    c2.push_back(40);
    c2.push_back(50);
    c2.push_back(60);

    cout << "c1 =";
    for (auto c : c1)
        cout << " " << c;
    cout << endl;

    Iter = c1.begin();
    Iter++;
    c1.insert(Iter, 100);
    cout << "c1 =";
    for (auto c : c1)
        cout << " " << c;
    cout << endl;

    Iter = c1.begin();
    Iter++;
    Iter++;
    c1.insert(Iter, 2, 200);

    cout << "c1 =";
    for(auto c : c1)
        cout << " " << c;
    cout << endl;

    c1.insert(++c1.begin(), c2.begin(), --c2.end());

    cout << "c1 =";
    for (auto c : c1)
        cout << " " << c;
    cout << endl;

    // initialize a list of strings by moving
    list < string > c3;
    string str("a");

    c3.insert(c3.begin(), move(str));
    cout << "Moved first element: " << c3.front() << endl;

    // Assign with an initializer_list
    list <int> c4{ {1, 2, 3, 4} };
    c4.insert(c4.begin(), { 5, 6, 7, 8 });

    cout << "c4 =";
    for (auto c : c4)
        cout << " " << c;
    cout << endl;
}

`iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem jedes Element in einer Liste gelesen oder geändert werden kann.

typedef implementation-defined iterator;

Hinweise

Ein Typ iterator kann verwendet werden, um den Wert eines Elements zu ändern.

Beispiel

Ein Beispiel hierfür finden Sie unter begin.

`list`

Erstellt eine Liste einer bestimmten Größe bzw. mit Elementen eines bestimmten Werts oder mit einer bestimmten Zuweisung oder als vollständige bzw. teilweise Kopie einer anderen Liste.

list();
explicit list(const Allocator& Al);
explicit list(size_type Count);
list(size_type Count, const Type& Val);
list(size_type Count, const Type& Val, const Allocator& Al);

list(const list& Right);
list(list&& Right);
list(initializer_list<Type> IList, const Allocator& Al);

template <class InputIterator>
list(InputIterator First, InputIterator Last);

template <class InputIterator>
list(InputIterator First, InputIterator Last, const Allocator& Al);

Parameter

Al
Die mit diesem Objekt zu verwendende Zuweisungsklasse.

Count
Die Anzahl von Elementen in der erstellten Liste.

Val
Der Werttyp der Elemente in der Liste.

Right
Die Liste, deren Kopie die erstellte Liste ist.

First
Die Position des ersten Elements in dem zu kopierenden Elementbereich.

Last
Die Position des ersten Elements nach dem zu kopierenden Elementbereich.

IList
Das initializer_list-Element, das die zu kopierenden Elemente enthält.

Hinweise

Alle Konstruktoren speichern ein Allocator-Objekt (Al) und initialisieren die Liste.

get_allocator gibt eine Kopie des Allocator-Objekts zurück, das zum Erstellen einer Liste verwendet wird.

Die ersten beiden Konstruktoren geben eine leere Anfangsliste an, die zweite, die den zu verwendenden Allocatortyp (Al) angibt.

Der dritte Konstruktor gibt eine Wiederholung einer angegebenen Anzahl (Count) von Elementen des Standardwerts für die Klasse Type an.

Die vierten und fünften Konstruktoren geben eine Wiederholung von (Count) Elementen des Werts Valan.

Der sechste Konstruktor gibt eine Kopie der Liste Right an.

Der siebte Konstruktor verschiebt die Liste Right.

Beim achten Konstruktor wird zum Angeben des Elements ein initializer_list-Element verwendet.

Die folgenden zwei Konstruktoren kopieren den [First, Last)-Bereich einer Liste.

Keine der Konstruktoren führen Zwischenneuzuordnungen aus.

Beispiel

// list_class_list.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main()
{
    using namespace std;
    // Create an empty list c0
    list <int> c0;

    // Create a list c1 with 3 elements of default value 0
    list <int> c1(3);

    // Create a list c2 with 5 elements of value 2
    list <int> c2(5, 2);

    // Create a list c3 with 3 elements of value 1 and with the
    // allocator of list c2
    list <int> c3(3, 1, c2.get_allocator());

    // Create a copy, list c4, of list c2
    list <int> c4(c2);

    // Create a list c5 by copying the range c4[ first,  last)
    list <int>::iterator c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    list <int> c5(c4.begin(), c4_Iter);

    // Create a list c6 by copying the range c4[ first,  last) and with
    // the allocator of list c2
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    c4_Iter++;
    list <int> c6(c4.begin(), c4_Iter, c2.get_allocator());

    cout << "c1 =";
    for (auto c : c1)
        cout << " " << c;
    cout << endl;

    cout << "c2 =";
    for (auto c : c2)
        cout << " " << c;
    cout << endl;

    cout << "c3 =";
    for (auto c : c3)
        cout << " " << c;
    cout << endl;

    cout << "c4 =";
    for (auto c : c4)
        cout << " " << c;
    cout << endl;

    cout << "c5 =";
    for (auto c : c5)
        cout << " " << c;
    cout << endl;

    cout << "c6 =";
    for (auto c : c6)
        cout << " " << c;
    cout << endl;

    // Move list c6 to list c7
    list <int> c7(move(c6));
    cout << "c7 =";
    for (auto c : c7)
        cout << " " << c;
    cout << endl;

    // Construct with initializer_list
    list<int> c8({ 1, 2, 3, 4 });
    cout << "c8 =";
    for (auto c : c8)
        cout << " " << c;
    cout << endl;
}

c1 = 0 0 0c2 = 2 2 2 2 2c3 = 1 1 1c4 = 2 2 2 2 2c5 = 2 2c6 = 2 2 2c7 = 2 2 2c8 = 1 2 3 4

`max_size`

Gibt die Maximallänge einer Liste zurück.

size_type max_size() const;

Rückgabewert

Die mögliche Maximallänge der Liste.

Beispiel

// list_max_size.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::size_type i;

   i = c1.max_size( );
   cout << "Maximum possible length of the list is " << i << "." << endl;
}

`merge`

Entfernt die Elemente aus der Argumentliste, fügt sie in die Zielliste ein und sortiert den neuen, kombinierten Elementsatz in aufsteigender Reihenfolge oder in einer anderen angegebenen Reihenfolge.

void merge(list<Type, Allocator>& right);

template <class Traits>
void merge(list<Type, Allocator>& right, Traits comp);

Parameter

right
Die Argumentliste, die mit der Zielliste zusammengeführt werden soll.

comp
Der Vergleichsoperator, der zum Sortieren der Elemente in der Zielliste verwendet wird.

Hinweise

Die Argumentliste right wird mit der Zielliste zusammengeführt.

Die Argument- und die Zielliste müssen mit derselben Vergleichsbeziehung sortiert werden, mit der die resultierende Sequenz sortiert werden soll. Die Standardreihenfolge für die erste Member-Funktion ist die aufsteigende Reihenfolge. Die zweite Memberfunktion setzt den vom Benutzer angegebenen Vergleichsvorgang comp der Klasse Traitsauf.

Beispiel

// list_merge.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1, c2, c3;
   list <int>::iterator c1_Iter, c2_Iter, c3_Iter;

   c1.push_back( 3 );
   c1.push_back( 6 );
   c2.push_back( 2 );
   c2.push_back( 4 );
   c3.push_back( 5 );
   c3.push_back( 1 );

   cout << "c1 =";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   cout << "c2 =";
   for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
      cout << " " << *c2_Iter;
   cout << endl;

   c2.merge( c1 );  // Merge c1 into c2 in (default) ascending order
   c2.sort( greater<int>( ) );
   cout << "After merging c1 with c2 and sorting with >: c2 =";
   for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
      cout << " " << *c2_Iter;
   cout << endl;

   cout << "c3 =";
   for ( c3_Iter = c3.begin( ); c3_Iter != c3.end( ); c3_Iter++ )
      cout << " " << *c3_Iter;
   cout << endl;

   c2.merge( c3, greater<int>( ) );
   cout << "After merging c3 with c2 according to the '>' comparison relation: c2 =";
   for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
      cout << " " << *c2_Iter;
   cout << endl;
}

c1 = 3 6
c2 = 2 4
After merging c1 with c2 and sorting with >: c2 = 6 4 3 2
c3 = 5 1
After merging c3 with c2 according to the '>' comparison relation: c2 = 6 5 4 3 2 1

`operator=`

Ersetzt die Elemente der Liste mit einer Kopie einer anderen Liste.

list& operator=(const list& right);
list& operator=(list&& right);

Parameter

right
Das list kopierte In das list.

Hinweise

Nachdem ein vorhandenes Element in einer list gelöscht wurde, kopiert oder verschiebt der Operator den Inhalt von right in die list.

Beispiel

// list_operator_as.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list<int> v1, v2, v3;
   list<int>::iterator iter;

   v1.push_back(10);
   v1.push_back(20);
   v1.push_back(30);
   v1.push_back(40);
   v1.push_back(50);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << *iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = forward< list<int> >(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;
}

`pointer`

Stellt einen Zeiger auf ein Element in einer Liste bereit.

typedef typename Allocator::pointer pointer;

Hinweise

Ein Typ pointer kann verwendet werden, um den Wert eines Elements zu ändern.

In den meisten Fällen sollte ein iterator Element für den Zugriff auf die Elemente in einem Listenobjekt verwendet werden.

`pop_back`

Löscht das Element am Ende einer Liste.

void pop_back();

Hinweise

Das letzte Element darf nicht leer sein. pop_back löst nie eine Ausnahme aus.

Beispiel

// list_pop_back.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The last element is: " << c1.back( ) << endl;

   c1.pop_back( );
   cout << "After deleting the element at the end of the list, "
           "the last element is: " << c1.back( ) << endl;
}

The first element is: 1
The last element is: 2
After deleting the element at the end of the list, the last element is: 1

`pop_front`

Löscht das Element am Anfang einer Liste.

void pop_front();

Hinweise

Das erste Element darf nicht leer sein. pop_front löst nie eine Ausnahme aus.

Beispiel

// list_pop_front.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The second element is: " << c1.back( ) << endl;

   c1.pop_front( );
   cout << "After deleting the element at the beginning of the list, "
         "the first element is: " << c1.front( ) << endl;
}

The first element is: 1
The second element is: 2
After deleting the element at the beginning of the list, the first element is: 2

`push_back`

Fügt am Ende einer Liste ein Element hinzu.

void push_back(const Type& val);
void push_back(Type&& val);

Parameter

val
Das Element, das am Ende der Liste hinzugefügt wird.

Hinweise

Wenn eine Ausnahme ausgelöst wird, bleibt die Liste unverändert, und die Ausnahme wird erneut ausgelöst.

Beispiel

// list_push_back.cpp
// compile with: /EHsc
#include <list>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   list <int> c1;

   c1.push_back( 1 );
   if ( c1.size( ) != 0 )
      cout << "Last element: " << c1.back( ) << endl;

   c1.push_back( 2 );
   if ( c1.size( ) != 0 )
      cout << "New last element: " << c1.back( ) << endl;

// move initialize a list of strings
   list <string> c2;
   string str("a");

   c2.push_back( move( str ) );
   cout << "Moved first element: " << c2.back( ) << endl;
}

Last element: 1
New last element: 2
Moved first element: a

`push_front`

Fügt am Anfang einer Liste ein Element hinzu.

void push_front(const Type& val);
void push_front(Type&& val);

Parameter

val
Das am Anfang der Liste hinzugefügte Element.

Hinweise

Wenn eine Ausnahme ausgelöst wird, bleibt die Liste unverändert, und die Ausnahme wird erneut ausgelöst.

Beispiel

// list_push_front.cpp
// compile with: /EHsc
#include <list>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   list <int> c1;

   c1.push_front( 1 );
   if ( c1.size( ) != 0 )
      cout << "First element: " << c1.front( ) << endl;

   c1.push_front( 2 );
   if ( c1.size( ) != 0 )
      cout << "New first element: " << c1.front( ) << endl;

// move initialize a list of strings
   list <string> c2;
   string str("a");

   c2.push_front( move( str ) );
   cout << "Moved first element: " << c2.front( ) << endl;
}

First element: 1
New first element: 2
Moved first element: a

`rbegin`

Gibt einen Iterator zurück, mit dem das erste Element in einer umgekehrten Liste behandelt wird.

const_reverse_iterator rbegin() const;
reverse_iterator rbegin();

Rückgabewert

Ein umgekehrter bidirektionalem Iterator, mit dem das erste Element in einer umgekehrten Liste adressiert wird (bzw. mit dem das ehemals letzte Element in der nicht umgekehrten Liste adressiert wird).

Hinweise

rbegin wird mit einer umgekehrten Liste verwendet, genau wie begin bei einer Liste.

Wenn rbegin dem Rückgabewert von const_reverse_iterator zugewiesen wird, kann das Listenobjekt nicht geändert werden. Wenn rbegin dem Rückgabewert von reverse_iterator zugewiesen wird, kann das Listenobjekt geändert werden.

Mit rbegin kann eine Liste rückwärts durchlaufen werden.

Beispiel

// list_rbegin.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::iterator c1_Iter;
   list <int>::reverse_iterator c1_rIter;

   // If the following line replaced the line above, *c1_rIter = 40;
   // (below) would be an error
   //list <int>::const_reverse_iterator c1_rIter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1_rIter = c1.rbegin( );
   cout << "The last element in the list is " << *c1_rIter << "." << endl;

   cout << "The list is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   // rbegin can be used to start an iteration through a list in
   // reverse order
   cout << "The reversed list is:";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << " " << *c1_rIter;
   cout << endl;

   c1_rIter = c1.rbegin( );
*c1_rIter = 40;
   cout << "The last element in the list is now " << *c1_rIter << "." << endl;
}

The last element in the list is 30.
The list is: 10 20 30
The reversed list is: 30 20 10
The last element in the list is now 40.

`reference`

Ein Typ, der einen Verweis auf ein in einer Liste gespeichertes Element bereitstellt.

typedef typename Allocator::reference reference;

Beispiel

// list_ref.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   int &i = c1.front( );
   int &j = c1.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`remove`

Löscht Elemente in einer Liste, die einen angegebenen Wert entsprechen.

void remove(const Type& val);

Parameter

val
Der Wert, der, sofern er von einem Element gehalten wird, das Entfernen dieses Elements aus der Liste verursacht.

Hinweise

Die Reihenfolge der verbleibenden Elemente ist nicht beeinflusst.

Beispiel

// list_remove.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::iterator c1_Iter, c2_Iter;

   c1.push_back( 5 );
   c1.push_back( 100 );
   c1.push_back( 5 );
   c1.push_back( 200 );
   c1.push_back( 5 );
   c1.push_back( 300 );

   cout << "The initial list is c1 =";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   list <int> c2 = c1;
   c2.remove( 5 );
   cout << "After removing elements with value 5, the list becomes c2 =";
   for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
      cout << " " << *c2_Iter;
   cout << endl;
}

The initial list is c1 = 5 100 5 200 5 300
After removing elements with value 5, the list becomes c2 = 100 200 300

`remove_if`

Löscht Elemente aus einer Liste, für die ein angegebenes Prädikat erfüllt ist.

template <class Predicate>
void remove_if(Predicate pred)

Parameter

pred
Das unäre Prädikat, das bei Erfüllung durch ein Element das Löschen dieses Elements in der Liste zur Folge hat.

Beispiel

// list_remove_if.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

template <class T> class is_odd : public std::unary_function<T, bool>
{
public:
   bool operator( ) ( T& val )
   {
   return ( val % 2 ) == 1;
   }
};

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::iterator c1_Iter, c2_Iter;

   c1.push_back( 3 );
   c1.push_back( 4 );
   c1.push_back( 5 );
   c1.push_back( 6 );
   c1.push_back( 7 );
   c1.push_back( 8 );

   cout << "The initial list is c1 =";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   list <int> c2 = c1;
   c2.remove_if( is_odd<int>( ) );

   cout << "After removing the odd elements, "
        << "the list becomes c2 =";
   for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
      cout << " " << *c2_Iter;
   cout << endl;
}

The initial list is c1 = 3 4 5 6 7 8
After removing the odd elements, the list becomes c2 = 4 6 8

`rend`

Gibt ein Iterator zurück, der den Standort adressiert, der dem letzten Element in einer umgekehrten Liste nachfolgt.

const_reverse_iterator rend() const;
reverse_iterator rend();

Rückgabewert

Ein umgekehrter bidirektionaler Iterator, der den Standort anspricht, der dem letzten Element in einer umgekehrten Liste nachfolgt (der Speicherort, der dem ersten Element in der nicht umgekehrten Liste vorangegangen war).

Hinweise

rend wird mit einer umgekehrten Liste verwendet, genau wie end bei einer Liste.

Wenn rend dem Rückgabewert von const_reverse_iterator zugewiesen wird, kann das Listenobjekt nicht geändert werden. Wenn rend dem Rückgabewert von reverse_iterator zugewiesen wird, kann das Listenobjekt geändert werden.

rend kann verwendet werden, um zu testen, ob das Ende der Liste von einem umgekehrten Iterator erreicht wurde.

Der von rend zurückgegebene Wert darf nicht dereferenziert werden.

Beispiel

// list_rend.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::iterator c1_Iter;
   list <int>::reverse_iterator c1_rIter;

   // If the following line had replaced the line above, an error would
   // have resulted in the line modifying an element (commented below)
   // because the iterator would have been const
   // list <int>::const_reverse_iterator c1_rIter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_rIter = c1.rend( );
   c1_rIter --;  // Decrementing a reverse iterator moves it forward in
                 // the list (to point to the first element here)
   cout << "The first element in the list is: " << *c1_rIter << endl;

   cout << "The list is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   // rend can be used to test if an iteration is through all of the
   // elements of a reversed list
   cout << "The reversed list is:";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << " " << *c1_rIter;
   cout << endl;

   c1_rIter = c1.rend( );
   c1_rIter--;  // Decrementing the reverse iterator moves it backward
                // in the reversed list (to the last element here)

*c1_rIter = 40;  // This modification of the last element would have
                    // caused an error if a const_reverse iterator had
                    // been declared (as noted above)

   cout << "The modified reversed list is:";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << " " << *c1_rIter;
   cout << endl;
}

The first element in the list is: 10
The list is: 10 20 30
The reversed list is: 30 20 10
The modified reversed list is: 30 20 40

`resize`

Gibt eine neue Größe für eine Liste an.

void resize(size_type _Newsize);
void resize(size_type _Newsize, Type val);

Parameter

_Newsize
Die neue Größe der verknüpften Liste.

val
Der Wert der neuen, der Liste hinzuzufügenden Elemente, wenn die neue Größe die ursprüngliche Größe überschreitet. Wenn der Wert ausgelassen wird, werden dem Standardwert die neuen Elemente für die Klasse zugewiesen.

Hinweise

Wenn die Größe der Liste kleiner ist, als die angeforderte Größe, werden der Liste _Newsize-Elemente hinzugefügt, bis sie die angeforderte Größe erreicht.

Wenn die Größe der Liste die angeforderte Größe übersteigt, werden die Elemente, die dem Ende der Liste am nächsten sind, gelöscht, bis die Liste die Größe _Newsize erreicht.

Wenn die vorhandene Größe der Liste der angeforderten Größe entspricht, wird keine Aktion durchgeführt.

size entspricht der aktuellen Größe der Liste.

Beispiel

// list_resize.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1.resize( 4,40 );
   cout << "The size of c1 is " << c1.size( ) << endl;
   cout << "The value of the last element is " << c1.back( ) << endl;

   c1.resize( 5 );
   cout << "The size of c1 is now " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;

   c1.resize( 2 );
   cout << "The reduced size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;
}

The size of c1 is 4
The value of the last element is 40
The size of c1 is now 5
The value of the last element is now 0
The reduced size of c1 is: 2
The value of the last element is now 20

`reverse`

Kehrt die Reihenfolge um, in der die Elemente in einer Liste auftreten.

void reverse();

Beispiel

// list_reverse.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::iterator c1_Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   cout << "c1 =";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   c1.reverse( );
   cout << "Reversed c1 =";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;
}

c1 = 10 20 30
Reversed c1 = 30 20 10

`reverse_iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem ein Element in einer umgekehrten Liste gelesen oder geändert werden kann.

typedef std::reverse_iterator<iterator> reverse_iterator;

Hinweise

Ein reverse_iterator-Typ wird verwendet, um die Liste in umgekehrter Reihenfolge zu durchlaufen.

Beispiel

Ein Beispiel hierfür finden Sie unter rbegin.

`size`

Gibt die Anzahl von Elementen in einer Liste zurück.

size_type size() const;

Rückgabewert

Die aktuelle Länge der Liste.

Beispiel

// list_size.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::size_type i;

   c1.push_back( 5 );
   i = c1.size( );
   cout << "List length is " << i << "." << endl;

   c1.push_back( 7 );
   i = c1.size( );
   cout << "List length is now " << i << "." << endl;
}

List length is 1.
List length is now 2.

`size_type`

Ein Typ, der die Anzahl von Elementen in einer Liste zählt.

typedef typename Allocator::size_type size_type;

Beispiel

Ein Beispiel hierfür finden Sie unter size.

`sort`

Ordnet die Elemente einer Liste in aufsteigender Reihenfolge oder in Bezug auf eine andere benutzerdefinierte Reihenfolge.

void sort();

template <class Traits>
    void sort(Traits comp);

Parameter

comp
Der zum Sortieren aufeinanderfolgender Elemente verwendete Vergleichsoperator.

Hinweise

Mit der ersten Memberfunktion werden die Elemente standardmäßig in eine aufsteigende Reihenfolge gebracht.

Die Membervorlagenfunktion ordnet die Elemente gemäß dem vom Benutzer angegebenen Vergleichsvorgang comp der Klasse Traitsan.

Beispiel

// list_sort.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::iterator c1_Iter;

   c1.push_back( 20 );
   c1.push_back( 10 );
   c1.push_back( 30 );

   cout << "Before sorting: c1 =";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   c1.sort( );
   cout << "After sorting c1 =";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   c1.sort( greater<int>( ) );
   cout << "After sorting with 'greater than' operation, c1 =";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;
}

Before sorting: c1 = 20 10 30
After sorting c1 = 10 20 30
After sorting with 'greater than' operation, c1 = 30 20 10

`splice`

Entfernt Elemente aus einer Quellliste und fügt sie in eine Zielliste ein.

// insert the entire source list
void splice(const_iterator Where, list<Type, Allocator>& Source);
void splice(const_iterator Where, list<Type, Allocator>&& Source);

// insert one element of the source list
void splice(const_iterator Where, list<Type, Allocator>& Source, const_iterator Iter);
void splice(const_iterator Where, list<Type, Allocator>&& Source, const_iterator Iter);

// insert a range of elements from the source list
void splice(const_iterator Where, list<Type, Allocator>& Source, const_iterator First, const_iterator Last);
void splice(const_iterator Where, list<Type, Allocator>&& Source, const_iterator First, const_iterator Last);

Parameter

Where
Die Position in der Zielliste, vor der die Elemente eingefügt werden sollen.

Source
Die Quellliste, die in die Zielliste eingefügt werden soll.

Iter
Das Element, das aus der Quellliste eingefügt werden soll.

First
Das erste Element im Bereich, das aus der Quellliste eingefügt werden soll.

Last
Die erste Position hinter dem letzten Element im Bereich, das aus der Quellliste eingefügt werden soll.

Hinweise

Das erste Paar von Memberfunktionen fügt alle Elemente in der Quellliste vor der Position, auf die durch Where verwiesen wird, in die Zielliste ein und entfernt alle Elemente aus der Quellliste. ( &Source darf nicht gleich this sein.)

Das zweite Elementpaar von Memberfunktionen fügt das Element Iter ein, auf das vor der Position in der Zielliste verwiesen wird, auf die Where verwiesen wird, und entfernt Iter aus der Quellliste. (Wenn Where == Iter || Where == ++Iter ist, findet keine Änderung statt.)

Das dritte Paar von Memberfunktionen fügt den durch (First, Last) festgelegten Bereich vor dem Element in der Zielliste ein, auf das durch Where verwiesen wird, und entfernt diesen Bereich von Elementen aus der Quellliste. (Wenn &Source == this ist, darf der Bereich [First, Last) nicht das Element enthalten, auf das von Where gezeigt wird.)

Wenn der Bereichsspliz Elemente einfügt N und &Source != thisein Objekt der Klasse iterator inkrementiert N wird.

In allen diesen Fällen bleiben Iteratoren, Zeiger oder Verweise, die auf zusammengeführte Elemente verweisen, gültig und werden in den Zielcontainer übertragen.

Beispiel

// list_splice.cpp
// compile with: /EHsc /W4
#include <list>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    list<int> c1{10,11};
    list<int> c2{20,21,22};
    list<int> c3{30,31};
    list<int> c4{40,41,42,43};

    list<int>::iterator where_iter;
    list<int>::iterator first_iter;
    list<int>::iterator last_iter;

    cout << "Beginning state of lists:" << endl;
    cout << "c1 = ";
    print(c1);
    cout << "c2 = ";
    print(c2);
    cout << "c3 = ";
    print(c3);
    cout << "c4 = ";
    print(c4);

    where_iter = c2.begin();
    ++where_iter; // start at second element
    c2.splice(where_iter, c1);
    cout << "After splicing c1 into c2:" << endl;
    cout << "c1 = ";
    print(c1);
    cout << "c2 = ";
    print(c2);

    first_iter = c3.begin();
    c2.splice(where_iter, c3, first_iter);
    cout << "After splicing the first element of c3 into c2:" << endl;
    cout << "c3 = ";
    print(c3);
    cout << "c2 = ";
    print(c2);

    first_iter = c4.begin();
    last_iter = c4.end();
    // set up to get the middle elements
    ++first_iter;
    --last_iter;
    c2.splice(where_iter, c4, first_iter, last_iter);
    cout << "After splicing a range of c4 into c2:" << endl;
    cout << "c4 = ";
    print(c4);
    cout << "c2 = ";
    print(c2);
}

Beginning state of lists:c1 = 2 elements: (10) (11)c2 = 3 elements: (20) (21) (22)c3 = 2 elements: (30) (31)c4 = 4 elements: (40) (41) (42) (43)After splicing c1 into c2:c1 = 0 elements:c2 = 5 elements: (20) (10) (11) (21) (22)After splicing the first element of c3 into c2:c3 = 1 elements: (31)c2 = 6 elements: (20) (10) (11) (30) (21) (22)After splicing a range of c4 into c2:c4 = 2 elements: (40) (43)c2 = 8 elements: (20) (10) (11) (30) (41) (42) (21) (22)

`swap`

Tauscht die Elemente zweier Listen aus.

void swap(list<Type, Allocator>& right);
friend void swap(list<Type, Allocator>& left, list<Type, Allocator>& right)

Parameter

right
Die Liste, in der die auszutauschenden Elemente bereitgestellt werden, oder die Liste, deren Elemente mit denen der Liste left ausgetauscht werden sollen.

left
Eine Liste, deren Elemente mit denen der Liste right ausgetauscht werden sollen.

Beispiel

// list_swap.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1, c2, c3;
   list <int>::iterator c1_Iter;

   c1.push_back( 1 );
   c1.push_back( 2 );
   c1.push_back( 3 );
   c2.push_back( 10 );
   c2.push_back( 20 );
   c3.push_back( 100 );

   cout << "The original list c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   c1.swap( c2 );

   cout << "After swapping with c2, list c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap( c1,c3 );

   cout << "After swapping with c3, list c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;
}

The original list c1 is: 1 2 3
After swapping with c2, list c1 is: 10 20
After swapping with c3, list c1 is: 100

`unique`

Entfernt benachbarte doppelte Elemente oder benachbarte Elemente, die einige andere binäre Prädikate aus einer Liste erfüllen.

void unique();

template <class BinaryPredicate>
void unique(BinaryPredicate pred);

Parameter

pred
Das binäre Prädikat, das zum Vergleichen von aufeinander folgenden Elementen verwendet wird.

Hinweise

Bei dieser Funktion wird davon ausgegangen, dass die Liste sortiert ist, sodass alle doppelten Elemente benachbart sind. Duplikate, die nicht nebeneinander angezeigt werden, werden nicht gelöscht.

Die erste Memberfunktion entfernt jedes Element, das mit dem vorherigen Element übereinstimmt.

Die zweite Memberfunktion entfernt jedes Element, das die Prädikatfunktion pred erfüllt, wenn ein Vergleich mit dem vorherigen Element durchgeführt wird. Sie können jedes der binären Funktionsobjekte verwenden, die in der <functional> Kopfzeile für das Argument pred deklariert sind, oder Sie können eigene erstellen.

Beispiel

// list_unique.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list <int> c1;
   list <int>::iterator c1_Iter, c2_Iter,c3_Iter;
   not_equal_to<int> mypred;

   c1.push_back( -10 );
   c1.push_back( 10 );
   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 20 );
   c1.push_back( -10 );

   cout << "The initial list is c1 =";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   list <int> c2 = c1;
   c2.unique( );
   cout << "After removing successive duplicate elements, c2 =";
   for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
      cout << " " << *c2_Iter;
   cout << endl;

   list <int> c3 = c2;
   c3.unique( mypred );
   cout << "After removing successive unequal elements, c3 =";
   for ( c3_Iter = c3.begin( ); c3_Iter != c3.end( ); c3_Iter++ )
      cout << " " << *c3_Iter;
   cout << endl;
}

The initial list is c1 = -10 10 10 20 20 -10
After removing successive duplicate elements, c2 = -10 10 20 -10
After removing successive unequal elements, c3 = -10 -10

`value_type`

Ein Typ, der den in einer Liste gespeicherten Datentyp darstellt.

typedef typename Allocator::value_type value_type;

Hinweise

value_type ist ein Synonym für den Vorlagenparameter Type.

Beispiel

// list_value_type.cpp
// compile with: /EHsc
#include <list>
#include <iostream>

int main( )
{
   using namespace std;
   list<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

Freigeben über

list-Klasse

Syntax

Parameter

Hinweise

Member

Konstruktoren

TypeDefs

Functions

Operatoren

Anforderungen

allocator_type

Hinweise

Beispiel

assign

Parameter

Hinweise

Beispiel

back

Rückgabewert

Hinweise

Beispiel

begin

Rückgabewert

Hinweise

Beispiel

cbegin

Rückgabewert

Hinweise

cend

Rückgabewert

Hinweise

clear

Beispiel

const_iterator

Hinweise

Beispiel

const_pointer

Hinweise

const_reference

Hinweise

Beispiel

const_reverse_iterator

Hinweise

Beispiel

crbegin

Rückgabewert

Hinweise

Beispiel

crend

Rückgabewert

Hinweise

Beispiel

difference_type

Hinweise

Beispiel

emplace

Parameter

Hinweise

Beispiel

emplace_back

Parameter

Hinweise

Beispiel

emplace_front

Parameter

Hinweise

Beispiel

empty

Rückgabewert

Beispiel

end

Rückgabewert

Hinweise

Beispiel

erase

Parameter

Rückgabewert

Hinweise

Beispiel

`list`-Klasse

`allocator_type`

`assign`

`back`

`begin`

`cbegin`

`cend`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`difference_type`

`emplace`

`emplace_back`

`emplace_front`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`list`

`max_size`

`merge`

`operator=`

`pointer`

`pop_back`

`pop_front`

`push_back`

`push_front`

`rbegin`

`reference`

`remove`

`remove_if`

`rend`

`resize`

`reverse`