`list` Klasa

Artykuł
06/16/2023

Klasa listy biblioteki standardowej języka C++ jest szablonem klasy kontenerów sekwencji, które utrzymują swoje elementy w układzie liniowym i umożliwiają wydajne wstawianie i usuwanie w dowolnej lokalizacji w sekwencji. Sekwencja jest przechowywana jako dwukierunkowa połączona lista elementów, z których każda zawiera element członkowski typu Type.

Składnia

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

Parametry

Type
Typ danych elementu, który ma być przechowywany na liście.

Allocator
Typ reprezentujący przechowywany obiekt alokatora, który hermetyzuje szczegóły dotyczące alokacji listy i cofnięcia alokacji pamięci. Ten argument jest opcjonalny, a wartość domyślna to allocator<Type>.

Uwagi

Wybór typu kontenera powinien ogólnie być oparty o typ wyszukiwania i wstawiania wymagany przez aplikację. Wektory powinny być preferowanym kontenerem do zarządzania sekwencją, gdy losowy dostęp do dowolnego elementu znajduje się w warstwie Premium, a operacje wstawiania lub usuwania elementów są wymagane tylko na końcu sekwencji. Wydajność kontenera deque klasy jest lepsza, gdy potrzebny jest dostęp losowy, a operacje wstawiania i usuwania zarówno na początku, jak i na końcu sekwencji są w warstwie Premium.

Funkcje mergeskładowe listy , , uniquereverse, removei remove_if zostały zoptymalizowane pod kątem operacji na obiektach listy i oferują wysoką wydajność alternatywę dla ich ogólnych odpowiedników.

Reallocation listy występuje, gdy funkcja składowa musi wstawić lub wymazać elementy listy. We wszystkich takich przypadkach tylko iteratory lub odwołania wskazujące wymazane części kontrolowanej sekwencji stają się nieprawidłowe.

Dołącz nagłówek <list> standardowej biblioteki C++, aby zdefiniować container listę szablonów klas i kilka szablonów pomocniczych.

Członkowie

Konstruktory

Nazwa/nazwisko	opis
`list`	Tworzy listę określonego rozmiaru lub z elementami określonej wartości lub z określoną `allocator` lub kopią innej listy.

Typedefs

Nazwa/nazwisko	opis
`allocator_type`	Typ reprezentujący klasę `allocator` dla obiektu listy.
`const_iterator`	Typ, który udostępnia iterator dwukierunkowy, który może odczytać `const` element na liście.
`const_pointer`	Typ, który dostarcza wskaźnik do `const` elementu na liście.
`const_reference`	Typ, który zawiera odwołanie do elementu przechowywanego `const` na liście na potrzeby odczytywania i wykonywania `const` operacji.
`const_reverse_iterator`	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać dowolny `const` element na liście.
`difference_type`	Typ, który zapewnia różnicę między dwoma iteratorami odwołującymi się do elementów na tej samej liście.
`iterator`	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować dowolny element na liście.
`pointer`	Typ, który dostarcza wskaźnik do elementu na liście.
`reference`	Typ, który zawiera odwołanie do elementu przechowywanego `const` na liście na potrzeby odczytywania i wykonywania `const` operacji.
`reverse_iterator`	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować element na odwróconej liście.
`size_type`	Typ, który zlicza liczbę elementów na liście.
`value_type`	Typ reprezentujący typ danych przechowywany na liście.

Funkcje

Nazwa/nazwisko	opis
`assign`	Usuwa elementy z listy i kopiuje nowy zestaw elementów do listy docelowej.
`back`	Zwraca odwołanie do ostatniego elementu listy.
`begin`	Zwraca iterator odnoszący się do pierwszego elementu na liście.
`cbegin`	Zwraca iterator const odnoszący się do pierwszego elementu na liście.
`cend`	Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu na liście.
`clear`	Usuwa wszystkie elementy listy.
`crbegin`	Zwraca iterator const odnoszący się do pierwszego elementu na odwróconej liście.
`crend`	Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu na odwróconej liście.
`emplace`	Wstawia element skonstruowany na miejscu do listy w określonej pozycji.
`emplace_back`	Dodaje element skonstruowany na końcu listy.
`emplace_front`	Dodaje element skonstruowany na początku listy.
`empty`	Sprawdza, czy lista jest pusta.
`end`	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu na liście.
`erase`	Usuwa element lub zakres elementów na liście z określonych pozycji.
`front`	Zwraca odwołanie do pierwszego elementu na liście.
`get_allocator`	Zwraca kopię obiektu używanego `allocator` do konstruowania listy.
`insert`	Wstawia element lub kilka elementów lub zakres elementów do listy w określonej pozycji.
`max_size`	Zwraca maksymalną długość listy.
`merge`	Usuwa elementy z listy argumentów, wstawia je do listy docelowej i porządkuje nowy, połączony zestaw elementów w kolejności rosnącej lub w innej określonej kolejności.
`pop_back`	Usuwa element na końcu listy.
`pop_front`	Usuwa element na początku listy.
`push_back`	Dodaje element na końcu listy.
`push_front`	Dodaje element na początku listy.
`rbegin`	Zwraca iterator odnoszący się do pierwszego elementu na odwróconej liście.
`remove`	Usuwa elementy na liście, które pasują do określonej wartości.
`remove_if`	Usuwa elementy z listy, dla których jest spełniony określony predykat.
`rend`	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu na odwróconej liście.
`resize`	Określa nowy rozmiar listy.
`reverse`	Odwraca kolejność, w jakiej elementy występują na liście.
`size`	Zwraca liczbę elementów na liście.
`sort`	Rozmieszcza elementy listy w kolejności rosnącej lub w odniesieniu do innej relacji kolejności.
`splice`	Usuwa elementy z listy argumentów i wstawia je do listy docelowej.
`swap`	Wymienia elementy dwóch list.
`unique`	Usuwa sąsiadujące zduplikowane elementy lub sąsiadujące elementy, które spełniają inne predykaty binarne z listy.

Operatory

Nazwa/nazwisko	opis
`operator=`	Zamienia elementy listy na kopię innej listy.

Wymagania

Nagłówek: <list>

`allocator_type`

Typ reprezentujący klasę alokatora dla obiektu listy.

typedef Allocator allocator_type;

Uwagi

allocator_type jest synonimem parametru Allocatorszablonu .

Przykład

Zobacz przykład dla elementu get_allocator.

`assign`

Usuwa elementy z listy i kopiuje nowy zestaw elementów do listy docelowej.

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

void assign
    initializer_list<Type> IList);

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

Parametry

First
Pozycja pierwszego elementu w zakresie elementów do skopiowania z listy argumentów.

Last
Pozycja pierwszego elementu tuż poza zakresem elementów do skopiowania z listy argumentów.

Count
Liczba kopii elementu wstawionego do listy.

Val
Wartość elementu wstawionego do listy.

IList
Initializer_list, który zawiera elementy do wstawienia.

Uwagi

Po wymazaniu wszystkich istniejących elementów na liście docelowej przypisz określony zakres elementów z oryginalnej listy lub z innej listy do listy docelowej lub wstawia kopie nowego elementu określonej wartości do listy docelowej

Przykład

// 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`

Zwraca odwołanie do ostatniego elementu listy.

reference back();

const_reference back() const;

Wartość zwracana

Ostatni element listy. Jeśli lista jest pusta, wartość zwracana jest niezdefiniowana.

Uwagi

Jeśli zwracana wartość back elementu jest przypisana do const_referenceobiektu , nie można zmodyfikować obiektu listy. Jeśli wartość zwracana elementu jest przypisana back do referenceobiektu , można zmodyfikować obiekt listy.

Podczas kompilowania przy użyciu _ITERATOR_DEBUG_LEVEL wartości zdefiniowanej jako 1 lub 2 w przypadku próby uzyskania dostępu do elementu na pustej liście wystąpi błąd środowiska uruchomieniowego. Aby uzyskać więcej informacji, zobacz Sprawdzone iteratory .

Przykład

// 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`

Zwraca iterator odnoszący się do pierwszego elementu na liście.

const_iterator begin() const;

iterator begin();

Wartość zwracana

Iterator dwukierunkowy odnoszący się do pierwszego elementu na liście lub do lokalizacji, która zakończyła się powodzeniem pustej listy.

Uwagi

Jeśli wartość zwracana elementu jest przypisana begin do const_iteratorobiektu , nie można modyfikować elementów w obiekcie listy. Jeśli wartość zwracana begin elementu jest przypisana do iteratorobiektu , można zmodyfikować elementy w obiekcie listy.

Przykład

// 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`

const Zwraca iterator, który adresuje pierwszy element w zakresie.

const_iterator cbegin() const;

Wartość zwracana

const Iterator dostępu dwukierunkowego, który wskazuje pierwszy element zakresu lub lokalizację tuż poza końcem pustego zakresu (dla pustego zakresu, cbegin() == cend()).

Uwagi

Przy zwracanej wartości cbeginelementu nie można modyfikować elementów w zakresie.

Możesz użyć tej funkcji składowej zamiast funkcji składowej begin() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany w połączeniu ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje begin() i cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

Zwraca iterator, który adresuje lokalizację const tuż poza ostatnim elementem w zakresie.

const_iterator cend() const;

Wartość zwracana

const Iterator dostępu dwukierunkowego, który wskazuje tuż poza końcem zakresu.

Uwagi

cend służy do testowania, czy iterator przeszedł koniec jego zakresu.

Możesz użyć tej funkcji składowej zamiast funkcji składowej end() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany w połączeniu ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje end() i cend().

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

// i2 is Container<T>::const_iterator

Wartość zwracana przez cend nie powinna być wyłuszczone.

Wyczyść

Usuwa wszystkie elementy listy.

void clear();

Przykład

// 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`

Typ, który udostępnia iterator dwukierunkowy, który może odczytać const element na liście.

typedef implementation-defined const_iterator;

Uwagi

Nie można użyć typu const_iterator do modyfikowania wartości elementu.

Przykład

Zobacz przykład dla elementu back.

`const_pointer`

Dostarcza wskaźnik do const elementu na liście.

typedef typename Allocator::const_pointer const_pointer;

Uwagi

Nie można użyć typu const_pointer do modyfikowania wartości elementu.

W większości przypadków iterator element powinien być używany do uzyskiwania dostępu do elementów w obiekcie listy.

`const_reference`

Typ, który zawiera odwołanie do elementu przechowywanego const na liście na potrzeby odczytywania i wykonywania const operacji.

typedef typename Allocator::const_reference const_reference;

Uwagi

Nie można użyć typu const_reference do modyfikowania wartości elementu.

Przykład

// 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`

Typ, który udostępnia iterator dwukierunkowy, który może odczytywać dowolny const element na liście.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Uwagi

Typ const_reverse_iterator nie może modyfikować wartości elementu i jest używany do iterowania po liście w odwrotnej kolejności.

Przykład

Zobacz przykład dla elementu rbegin.

`crbegin`

Zwraca iterator const odnoszący się do pierwszego elementu na odwróconej liście.

const_reverse_iterator rbegin() const;

Wartość zwracana

Odwrotny iterator dwukierunkowy odnoszący się do pierwszego elementu na odwróconej liście (lub odnoszący się do tego, co było ostatnim elementem w niereversed ).list

Uwagi

crbegin jest używany z odwróconą listą tak samo, jak list::begin w przypadku elementu list.

Przy użyciu wartości zwracanej crbeginobiektu listy nie można modyfikować. list::rbegin można użyć do iterowania listy wstecz.

Przykład

// 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`

Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu na odwróconej liście.

const_reverse_iterator rend() const;

Wartość zwracana

Odwrotny iterator dwukierunkowy, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym list elemecie (lokalizacja, która poprzedzała pierwszy element w niereversedowanym list).

Uwagi

crend jest używany z odwróconą listą tak samo, jak list::end w przypadku elementu list.

Przy użyciu wartości zwracanej crendlist obiektu nie można modyfikować.

crend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec jego list.

Wartość zwracana przez crend nie powinna być wyłuszczone.

Przykład

// 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`

Typ liczby całkowitej ze znakiem, który może służyć do reprezentowania liczby elementów listy w zakresie między elementami wskazywanym przez iteratory.

typedef typename Allocator::difference_type difference_type;

Uwagi

Jest difference_type to typ zwracany podczas odejmowania lub przyrostowania przez iteratory kontenera. Element difference_type jest zwykle używany do reprezentowania liczby elementów w zakresie [ first, last) między iteratorami first i last, zawiera element wskazywany przez first i zakres elementów do, ale nie uwzględnia, element wskazywany przez last.

Należy pamiętać, że chociaż difference_type jest dostępny dla wszystkich iteratorów spełniających wymagania iteratora wejściowego, który obejmuje klasę iteratorów dwukierunkowych obsługiwanych przez kontenery odwracalne, takie jak zestaw, odejmowanie między iteratorami jest obsługiwane tylko przez iteratory dostępu losowego udostępniane przez kontener dostępu losowego, takie jak vector Klasa.

Przykład

// 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`

Wstawia element skonstruowany na miejscu do listy w określonej pozycji.

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

Parametry

Where
Pozycja w miejscu docelowym list , w którym wstawiono pierwszy element.

val
Element dodany na końcu elementu list.

Uwagi

Jeśli zgłaszany jest wyjątek, list pozostaje pozostawiony bez myślenia, a wyjątek zostanie ponownie zwrócony.

Przykład

// 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`

Dodaje element skonstruowany na końcu listy.

void emplace_back(Type&& val);

Parametry

val
Element dodany na końcu elementu list.

Uwagi

Jeśli zgłaszany jest wyjątek, list pozostaje pozostawiony bez myślenia, a wyjątek zostanie ponownie zwrócony.

Przykład

// 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`

Dodaje element skonstruowany na początku listy.

void emplace_front(Type&& val);

Parametry

val
Element dodany na początku elementu list.

Uwagi

Jeśli zgłaszany jest wyjątek, list pozostaje pozostawiony bez myślenia, a wyjątek zostanie ponownie zwrócony.

Przykład

// 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`

Sprawdza, czy lista jest pusta.

bool empty() const;

Wartość zwracana

true jeśli lista jest pusta; false jeśli lista nie jest pusta.

Przykład

// 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`

Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu na liście.

const_iterator end() const;
iterator end();

Wartość zwracana

Iterator dwukierunkowy, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu na liście. Jeśli lista jest pusta, to list::end == list::begin.

Uwagi

end służy do testowania, czy iterator osiągnął koniec swojej listy.

Przykład

// 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`

Usuwa element lub zakres elementów na liście z określonych pozycji.

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

Parametry

Where
Pozycja elementu, który ma zostać usunięty z listy.

first
Pozycja pierwszego elementu usuniętego z listy.

last
Pozycja tuż poza ostatnim elementem usuniętym z listy.

Wartość zwracana

Iterator dwukierunkowy, który wyznacza pierwszy element pozostały poza usuniętymi elementami lub wskaźnik na końcu listy, jeśli taki element nie istnieje.

Uwagi

Nie ma miejsca reallocation, więc iteratory i odwołania stają się nieprawidłowe tylko dla wymazanych elementów.

erase nigdy nie zgłasza wyjątku.

Przykład

// 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`

Zwraca odwołanie do pierwszego elementu na liście.

reference front();
const_reference front() const;

Wartość zwracana

Jeśli lista jest pusta, zwracanie jest niezdefiniowane.

Uwagi

Jeśli zwracana wartość front elementu jest przypisana do const_referenceobiektu , nie można zmodyfikować obiektu listy. Jeśli wartość zwracana elementu jest przypisana front do referenceobiektu , można zmodyfikować obiekt listy.

Przykład

// 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`

Zwraca kopię obiektu alokatora używanego do konstruowania listy.

Allocator get_allocator() const;

Wartość zwracana

Alokator używany przez listę.

Uwagi

Alokatory dla klasy listy określają sposób zarządzania magazynem przez klasę. Domyślne alokatory dostarczane z klasami kontenerów biblioteki standardowej języka C++ są wystarczające dla większości potrzeb programistycznych. Pisanie i używanie własnej klasy alokatora jest zaawansowanym tematem języka C++.

Przykład

// 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`

Wstawia element lub kilka elementów lub zakres elementów do listy w określonej pozycji.

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);

Parametry

Where
Pozycja na liście docelowej, na której wstawiono pierwszy element.

Val
Wartość elementu wstawionego do listy.

Count
Liczba elementów wstawionych do listy.

First
Pozycja pierwszego elementu w zakresie elementów na liście argumentów do skopiowania.

Last
Pozycja pierwszego elementu poza zakresem elementów na liście argumentów do skopiowania.

Wartość zwracana

Pierwsze dwie funkcje wstawiania zwracają iterator wskazujący położenie, w którym nowy element został wstawiony do listy.

Przykład

// 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`

Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować dowolny element na liście.

typedef implementation-defined iterator;

Uwagi

iterator Typ może służyć do modyfikowania wartości elementu.

Przykład

Zobacz przykład dla elementu begin.

`list`

Tworzy listę określonego rozmiaru lub z elementami określonej wartości lub z określonym alokatorem lub kopią wszystkich lub części innej listy.

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);

Parametry

Al
Klasa alokatora do wykorzystania z tym obiektem.

Count
Liczba elementów na skonstruowanej liście.

Val
Wartość elementów na liście.

Right
Lista, której skonstruowana lista ma być kopią.

First
Położenie pierwszego elementu w zakresie elementów do skopiowania.

Last
Położenie pierwszego elementu poza zakresem elementów do skopiowania.

IList
Initializer_list, który zawiera elementy do skopiowania.

Uwagi

Wszystkie konstruktory przechowują obiekt alokatora (Al) i inicjują listę.

get_allocator Zwraca kopię obiektu alokatora używanego do konstruowania listy.

Pierwsze dwa konstruktory określają pustą listę początkową, drugą określającą typ alokatora (Al) do użycia.

Trzeci konstruktor określa powtórzenie określonej liczby (Count) elementów wartości domyślnej dla klasy Type.

Czwarte i piąte konstruktory określają powtórzenieCount () elementów wartości Val.

Szósty konstruktor określa kopię listy Right.

Siódmy konstruktor przenosi listę Right.

Ósmy konstruktor używa initializer_list do określenia elementów.

Dwa następne konstruktory kopiują zakres [First, Last) listy.

Żaden z konstruktorów nie wykonuje żadnych tymczasowych reallocations.

Przykład

// 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`

Zwraca maksymalną długość listy.

size_type max_size() const;

Wartość zwracana

Maksymalna możliwa długość listy.

Przykład

// 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`

Usuwa elementy z listy argumentów, wstawia je do listy docelowej i porządkuje nowy, połączony zestaw elementów w kolejności rosnącej lub w innej określonej kolejności.

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

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

Parametry

right
Lista argumentów do scalenia z listą docelową.

comp
Operator porównania używany do porządkowenia elementów listy docelowej.

Uwagi

Lista right argumentów jest scalona z listą docelową.

Listy argumentów i elementów docelowych muszą być uporządkowane z tą samą relacją porównania, według której sekwencja wynikowa ma być uporządkowana. Domyślna kolejność pierwszej funkcji składowej to kolejność rosnąca. Druga funkcja składowa nakłada operację comp porównania określonego przez użytkownika klasy Traits.

Przykład

// 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=`

Zamienia elementy listy na kopię innej listy.

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

Parametry

right
Element list kopiowany do pliku list.

Uwagi

Po wymazaniu wszystkich istniejących elementów w obiekcie listoperator kopiuje lub przenosi zawartość right do elementu list.

Przykład

// 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`

Dostarcza wskaźnik do elementu na liście.

typedef typename Allocator::pointer pointer;

Uwagi

pointer Typ może służyć do modyfikowania wartości elementu.

W większości przypadków iterator element powinien być używany do uzyskiwania dostępu do elementów w obiekcie listy.

`pop_back`

Usuwa element na końcu listy.

void pop_back();

Uwagi

Ostatni element nie może być pusty. pop_back nigdy nie zgłasza wyjątku.

Przykład

// 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`

Usuwa element na początku listy.

void pop_front();

Uwagi

Pierwszy element nie może być pusty. pop_front nigdy nie zgłasza wyjątku.

Przykład

// 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`

Dodaje element na końcu listy.

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

Parametry

val
Element dodany na końcu listy.

Uwagi

Jeśli zostanie zgłoszony wyjątek, lista pozostanie niezauniknięta, a wyjątek zostanie ponownie zgłoszony.

Przykład

// 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`

Dodaje element na początku listy.

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

Parametry

val
Element dodany na początku listy.

Uwagi

Jeśli zostanie zgłoszony wyjątek, lista pozostanie niezauniknięta, a wyjątek zostanie ponownie zgłoszony.

Przykład

// 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`

Zwraca iterator, który adresuje pierwszy element na odwróconej liście.

const_reverse_iterator rbegin() const;
reverse_iterator rbegin();

Wartość zwracana

Odwrotny iterator dwukierunkowy odnoszący się do pierwszego elementu na odwróconej liście (lub adresowania tego, co było ostatnim elementem na liście niereversed).

Uwagi

rbegin jest używana z odwróconą listą tak samo, jak begin jest używana z listą.

Jeśli zwracana wartość rbegin elementu jest przypisana do const_reverse_iteratorobiektu , nie można zmodyfikować obiektu listy. Jeśli wartość zwracana elementu jest przypisana rbegin do reverse_iteratorobiektu , można zmodyfikować obiekt listy.

rbegin można użyć do iterowania listy wstecz.

Przykład

// 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`

Typ, który zawiera odwołanie do elementu przechowywanego na liście.

typedef typename Allocator::reference reference;

Przykład

// 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`

Usuwa elementy na liście, które pasują do określonej wartości.

void remove(const Type& val);

Parametry

val
Wartość, która, jeśli jest przechowywana przez element, spowoduje usunięcie tego elementu z listy.

Uwagi

Kolejność pozostałych elementów nie ma wpływu.

Przykład

// 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`

Usuwa elementy z listy, dla których określony predykat jest spełniony.

template <class Predicate>
void remove_if(Predicate pred)

Parametry

pred
Predykat jednoargumentowy, który, jeśli został spełniony przez element, powoduje usunięcie tego elementu z listy.

Przykład

// 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`

Zwraca iterator, który adresuje lokalizację, która jest zgodna z ostatnim elementem na odwróconej liście.

const_reverse_iterator rend() const;
reverse_iterator rend();

Wartość zwracana

Iterator odwrotny dwukierunkowy, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu na odwróconej liście (lokalizacja, która poprzedzała pierwszy element na liście niewzreversed).

Uwagi

rend jest używana z odwróconą listą tak samo, jak end jest używana z listą.

Jeśli zwracana wartość rend elementu jest przypisana do const_reverse_iteratorobiektu , nie można zmodyfikować obiektu listy. Jeśli wartość zwracana elementu jest przypisana rend do reverse_iteratorobiektu , można zmodyfikować obiekt listy.

rend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec listy.

Wartość zwracana przez rend nie powinna być wyłuszczone.

Przykład

// 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`

Określa nowy rozmiar listy.

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

Parametry

_Newsize
Nowy rozmiar listy.

val
Wartość nowych elementów do dodania do listy, jeśli nowy rozmiar jest większy niż rozmiar oryginalny. Jeśli wartość zostanie pominięta, nowe elementy zostaną przypisane do wartości domyślnej klasy.

Uwagi

Jeśli rozmiar listy jest mniejszy niż żądany rozmiar, _Newsizeelementy zostaną dodane do listy do momentu osiągnięcia żądanego rozmiaru.

Jeśli rozmiar listy jest większy niż żądany rozmiar, elementy znajdujące się najbliżej końca listy zostaną usunięte, dopóki lista nie osiągnie rozmiaru _Newsize.

Jeśli rozmiar listy jest taki sam jak żądany rozmiar, nie zostanie podjęta żadna akcja.

size odzwierciedla bieżący rozmiar listy.

Przykład

// 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`

Odwraca kolejność, w jakiej elementy występują na liście.

void reverse();

Przykład

// 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`

Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować element na odwróconej liście.

typedef std::reverse_iterator<iterator> reverse_iterator;

Uwagi

Typ reverse_iterator służy do iterowania po liście w odwrotnej kolejności.

Przykład

Zobacz przykład dla elementu rbegin.

`size`

Zwraca liczbę elementów na liście.

size_type size() const;

Wartość zwracana

Bieżąca długość listy.

Przykład

// 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`

Typ, który zlicza liczbę elementów na liście.

typedef typename Allocator::size_type size_type;

Przykład

Zobacz przykład dla elementu size.

`sort`

Rozmieszcza elementy listy w kolejności rosnącej lub w odniesieniu do innej kolejności określonej przez użytkownika.

void sort();

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

Parametry

comp
Operator porównania służący do zamawiania kolejnych elementów.

Uwagi

Pierwsza funkcja składowa domyślnie umieszcza elementy w kolejności rosnącej.

Funkcja szablonu składowego porządkuje elementy zgodnie z operacją comp porównania określonego przez użytkownika klasy Traits.

Przykład

// 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`

Usuwa elementy z listy źródłowej i wstawia je do listy docelowej.

// 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);

Parametry

Where
Pozycja na liście docelowej, przed którą należy wstawić.

Source
Lista źródłowa, która ma zostać wstawiona do listy docelowej.

Iter
Element, który ma zostać wstawiony z listy źródłowej.

First
Pierwszy element w zakresie, który ma zostać wstawiony z listy źródłowej.

Last
Pierwsze położenie poza ostatnim elementem w zakresie, który ma zostać wstawiony z listy źródłowej.

Uwagi

Pierwsza para funkcji składowych wstawia wszystkie elementy na liście źródłowej do listy docelowej przed położeniem, do którego odwołuje się Where i usuwa wszystkie elementy z listy źródłowej. (&Source nie może być równe this.)

Druga para funkcji składowych wstawia element, do którego odwołuje się pozycja na liście docelowej, do której odwołuje Iter się i usuwa iter z Where listy źródłowej. (Jeśli Where == Iter || Where == ++Iternie nastąpi żadna zmiana).

Trzecia para funkcji składowych wstawia zakres wyznaczony przez [ First, Last) przed elementem na liście docelowej, do której odwołuje się Where i usuwa ten zakres elementów z listy źródłowej. (Jeśli &Source == thiszakres [First, Last) nie może zawierać elementu wskazywanego przez Where.

Jeśli zakresowy splice wstawia N elementy i &Source != this, obiekt klasy iterator jest zwiększany N razy.

We wszystkich przypadkach iteratory, wskaźniki lub odwołania odwołujące się do elementów połączonych pozostają prawidłowe i są przenoszone do kontenera docelowego.

Przykład

// 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`

Wymienia elementy dwóch list.

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

Parametry

right
Lista dostarczająca elementy do zamiany lub lista, których elementy mają być wymieniane z elementami listy left.

left
Lista, której elementy mają być wymieniane z listą right.

Przykład

// 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`

Usuwa sąsiadujące zduplikowane elementy lub sąsiadujące elementy, które spełniają inne predykat binarny z listy.

void unique();

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

Parametry

pred
Predykat binarny używany do porównywania kolejnych elementów.

Uwagi

Ta funkcja zakłada, że lista jest sortowana, tak aby wszystkie zduplikowane elementy sąsiadujące. Duplikaty, które nie sąsiadują, nie zostaną usunięte.

Pierwsza funkcja składowa usuwa każdy element, który porównuje się z poprzednim elementem.

Druga funkcja składowa usuwa każdy element, który spełnia funkcję pred predykatu w porównaniu z poprzednim elementem. Możesz użyć dowolnych obiektów funkcji binarnych zadeklarowanych w nagłówku <functional> dla argumentu pred lub utworzyć własne.

Przykład

// 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`

Typ reprezentujący typ danych przechowywany na liście.

typedef typename Allocator::value_type value_type;

Uwagi

value_type jest synonimem parametru Typeszablonu .

Przykład

// 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;
}

list Klasa

Składnia

Parametry

Uwagi

Członkowie

Konstruktory

Typedefs

Funkcje

Operatory

Wymagania

allocator_type

Uwagi

Przykład

assign

Parametry

Uwagi

Przykład

back

Wartość zwracana

Uwagi

Przykład

begin

Wartość zwracana

Uwagi

Przykład

cbegin

Wartość zwracana

Uwagi

cend

Wartość zwracana

Uwagi

Wyczyść

Przykład

const_iterator

Uwagi

Przykład

const_pointer

Uwagi

const_reference

Uwagi

Przykład

const_reverse_iterator

Uwagi

Przykład

crbegin

Wartość zwracana

Uwagi

Przykład

crend

Wartość zwracana

Uwagi

Przykład

difference_type

Uwagi

Przykład

emplace

Parametry

Uwagi

Przykład

emplace_back

Parametry

Uwagi

Przykład

emplace_front

Parametry

Uwagi

Przykład

empty

Wartość zwracana

Przykład

end

Wartość zwracana

Uwagi

Przykład

erase

Parametry

Wartość zwracana

Uwagi

Przykład

front

`list` Klasa

`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`

`reverse_iterator`