`list` Třída

Článek
10/12/2023

Třída seznamu standardní knihovny jazyka C++ je šablona třídy kontejnerů sekvence, která udržuje jejich prvky v lineárním uspořádání a umožňuje efektivní vkládání a odstraňování v libovolném umístění v rámci sekvence. Sekvence je uložena jako obousměrný propojený seznam prvků, z nichž každý obsahuje člen určitého typu Type.

Syntaxe

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

Parametry

Type
Datový typ prvku, který má být uložen v seznamu.

Allocator
Typ, který představuje uložený objekt alokátoru, který zapouzdřuje podrobnosti o přidělení seznamu a uvolnění paměti. Tento argument je nepovinný a výchozí hodnota je allocator<Type>.

Poznámky

Volba typu kontejneru by měla obecně vycházet z typu vyhledávání a vkládání vyžadovaného aplikací. Vektory by měly být upřednostňovaným kontejnerem pro správu sekvence, pokud je náhodný přístup k libovolnému prvku na úrovni Premium a vložení nebo odstranění prvků jsou vyžadovány pouze na konci sekvence. Výkon kontejneru deque třídy je vynikající, když je potřeba náhodný přístup a vložení a odstranění na začátku i na konci sekvence jsou na úrovni Premium.

Členské funkce mergeseznamu , removereverseuniquea remove_if byly optimalizovány pro operace s objekty seznamu a nabízejí vysoce výkonnou alternativu k jejich obecným protějškům.

K reallokaci seznamu dochází, když členová funkce musí vložit nebo vymazat prvky seznamu. Ve všech takových případech se zneplatní pouze iterátory nebo odkazy, které ukazují na vymazané části řízené sekvence.

Zahrňte standardní hlavičku <list> standardní knihovny C++, která definuje container seznam šablon tříd a několik podpůrných šablon.

Členové

Konstruktory

Jméno	popis
`list`	Vytvoří seznam určité velikosti nebo s prvky určité hodnoty nebo s určitým `allocator` nebo jako kopií některého jiného seznamu.

Typedefs

Jméno	popis
`allocator_type`	Typ, který představuje `allocator` třídu pro objekt seznamu.
`const_iterator`	Typ, který poskytuje obousměrný iterátor, který může číst `const` prvek v seznamu.
`const_pointer`	Typ, který poskytuje ukazatel na `const` prvek v seznamu.
`const_reference`	Typ, který poskytuje odkaz na `const` prvek uložený v seznamu pro čtení a provádění `const` operací.
`const_reverse_iterator`	Typ, který poskytuje obousměrný iterátor, který může číst libovolný `const` prvek v seznamu.
`difference_type`	Typ, který poskytuje rozdíl mezi dvěma iterátory, které odkazují na prvky ve stejném seznamu.
`iterator`	Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat libovolný prvek v seznamu.
`pointer`	Typ, který poskytuje ukazatel na prvek v seznamu.
`reference`	Typ, který poskytuje odkaz na `const` prvek uložený v seznamu pro čtení a provádění `const` operací.
`reverse_iterator`	Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat prvek v obráceném seznamu.
`size_type`	Typ, který spočítá počet prvků v seznamu.
`value_type`	Typ, který představuje datový typ uložený v seznamu.

Funkce

Jméno	popis
`assign`	Vymaže prvky ze seznamu a zkopíruje novou sadu prvků do cílového seznamu.
`back`	Vrátí odkaz na poslední prvek seznamu.
`begin`	Vrátí iterátor adresovaný prvním prvkem v seznamu.
`cbegin`	Vrátí konstantní iterátor adresovaný prvním prvkem v seznamu.
`cend`	Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v seznamu.
`clear`	Vymaže všechny prvky seznamu.
`crbegin`	Vrátí konstantní iterátor adresovaný prvním prvkem v obráceném seznamu.
`crend`	Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v obráceném seznamu.
`emplace`	Vloží prvek vytvořený na místě do seznamu na určené pozici.
`emplace_back`	Přidá prvek vytvořený na místě na konec seznamu.
`emplace_front`	Přidá prvek vytvořený na místě na začátek seznamu.
`empty`	Testuje, jestli je seznam prázdný.
`end`	Vrátí iterátor adresující umístění úspěšného posledního prvku v seznamu.
`erase`	Odebere prvek nebo rozsah prvků v seznamu ze zadaných pozic.
`front`	Vrátí odkaz na první prvek v seznamu.
`get_allocator`	Vrátí kopii objektu `allocator` použitého k vytvoření seznamu.
`insert`	Vloží prvek nebo počet prvků nebo rozsah prvků do seznamu na zadané pozici.
`max_size`	Vrátí maximální délku seznamu.
`merge`	Odebere prvky ze seznamu argumentů, vloží je do cílového seznamu a objedná novou sloučenou sadu prvků ve vzestupném pořadí nebo v jiném zadaném pořadí.
`pop_back`	Odstraní prvek na konci seznamu.
`pop_front`	Odstraní prvek na začátku seznamu.
`push_back`	Přidá prvek na konec seznamu.
`push_front`	Přidá prvek na začátek seznamu.
`rbegin`	Vrátí iterátor adresovaný první prvek v obráceném seznamu.
`remove`	Vymaže prvky v seznamu, které odpovídají zadané hodnotě.
`remove_if`	Vymaže prvky ze seznamu, pro který je zadaný predikát splněn.
`rend`	Vrátí iterátor, který bude adresovat umístění úspěšné poslední prvek v obráceném seznamu.
`resize`	Určuje novou velikost seznamu.
`reverse`	Vrátí pořadí, ve kterém se prvky vyskytují v seznamu.
`size`	Vrátí počet prvků v seznamu.
`sort`	Uspořádá prvky seznamu ve vzestupném pořadí nebo s ohledem na nějaký jiný vztah pořadí.
`splice`	Odebere prvky ze seznamu argumentů a vloží je do cílového seznamu.
`swap`	Vymění prvky dvou seznamů.
`unique`	Odebere sousední duplicitní prvky nebo sousední prvky, které splňují některé jiné binární predikát ze seznamu.

Operátory

Jméno	popis
`operator=`	Nahradí prvky seznamu kopií jiného seznamu.

Požadavky

Hlavička: <list>

`allocator_type`

Typ, který představuje třídu alokátoru pro objekt seznamu.

typedef Allocator allocator_type;

Poznámky

allocator_type je synonymem parametru Allocatoršablony .

Příklad

Podívejte se na příklad pro get_allocator.

`assign`

Odstraní prvky ze seznamu a zkopíruje novou sadu prvků do cílového seznamu.

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
Pozice prvního prvku v rozsahu prvků, které se mají zkopírovat ze seznamu argumentů.

Last
Pozice prvního prvku za rozsahem prvků, které se mají zkopírovat ze seznamu argumentů.

Count
Počet kopií prvku vloženého do seznamu.

Val
Hodnota prvku vloženého do seznamu.

IList
Objekt initializer_list obsahující prvky, které mají být vloženy.

Poznámky

Po odstranění jakýchkoli prvků v cílovém seznamu přiřaďte buď vložení zadaného rozsahu prvků z původního seznamu nebo z některého jiného seznamu do cílového seznamu, nebo vložení kopií nového prvku zadané hodnoty do cílového seznamu.

Příklad

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

Vrátí odkaz na poslední prvek seznamu.

reference back();

const_reference back() const;

Vrácená hodnota

Poslední prvek seznamu. Pokud je seznam prázdný, návratová hodnota není definována.

Poznámky

Pokud je vrácená hodnota back přiřazena k objektu const_referenceseznamu, nelze upravit objekt seznamu. Pokud je vrácená hodnota back přiřazena k objektu referenceseznamu, lze upravit objekt seznamu.

Při kompilaci pomocí _ITERATOR_DEBUG_LEVEL definovaného jako 1 nebo 2 dojde k chybě za běhu, pokud se pokusíte získat přístup k prvku v prázdném seznamu. Další informace najdete v tématu Kontrola iterátorů .

Příklad

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

Vrátí iterátor adresovaný prvním prvkem v seznamu.

const_iterator begin() const;

iterator begin();

Vrácená hodnota

Obousměrný iterátor adresující první prvek v seznamu nebo do umístění úspěšného prázdného seznamu.

Poznámky

Pokud je vrácená hodnota begin přiřazena k objektu const_iteratorseznamu, nelze upravit prvky v objektu seznamu. Pokud je vrácená hodnota begin přiřazena k objektu iteratorseznamu, lze upravit prvky v objektu seznamu.

Příklad

// 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 Vrátí iterátor, který řeší první prvek v oblasti.

const_iterator cbegin() const;

Vrácená hodnota

const Obousměrný iterátor s přístupem, který odkazuje na první prvek rozsahu, nebo umístění těsně za koncem prázdné oblasti (pro prázdnou oblast, cbegin() == cend()).

Poznámky

Při návratové cbeginhodnotě nelze upravit prvky v oblasti.

Tuto členská funkce můžete použít místo begin() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá ve spojení s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje begin() a cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

const Vrátí iterátor, který řeší umístění za posledním prvkem v rozsahu.

const_iterator cend() const;

Vrácená hodnota

const Obousměrný iterátor s přístupem, který odkazuje těsně za koncem rozsahu.

Poznámky

cend slouží k otestování, zda iterátor předal konec jeho rozsahu.

Tuto členská funkce můžete použít místo end() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá ve spojení s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje end() a cend().

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

// i2 is Container<T>::const_iterator

Hodnota vrácená cend hodnotou by neměla být dereferenced.

Jasné

Vymaže všechny prvky seznamu.

void clear();

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst const prvek v seznamu.

typedef implementation-defined const_iterator;

Poznámky

Typ const_iterator nelze použít k úpravě hodnoty prvku.

Příklad

Podívejte se na příklad pro back.

`const_pointer`

Poskytuje ukazatel na const prvek v seznamu.

typedef typename Allocator::const_pointer const_pointer;

Poznámky

Typ const_pointer nelze použít k úpravě hodnoty prvku.

Ve většině případů iterator by se měla použít pro přístup k prvkům v objektu seznamu.

`const_reference`

Typ, který poskytuje odkaz na const prvek uložený v seznamu pro čtení a provádění const operací.

typedef typename Allocator::const_reference const_reference;

Poznámky

Typ const_reference nelze použít k úpravě hodnoty prvku.

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst libovolný const prvek v seznamu.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Poznámky

Typ const_reverse_iterator nemůže změnit hodnotu prvku a používá se k iteraci v seznamu obráceně.

Příklad

Podívejte se na příklad pro rbegin.

`crbegin`

Vrátí konstantní iterátor adresovaný prvním prvkem v obráceném seznamu.

const_reverse_iterator rbegin() const;

Vrácená hodnota

Konstantní obousměrný iterátor adresovaný prvním prvkem v obráceném seznamu (nebo adresování posledního prvku v nereverze list).

Poznámky

crbegin se používá s obráceným seznamem stejně, jako list::begin se používá s list.

Vrácenou hodnotou crbeginobjektu seznamu nelze změnit. list::rbegin lze použít k iteraci seznamu zpět.

Příklad

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

Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v obráceném seznamu.

const_reverse_iterator rend() const;

Vrácená hodnota

Const reverse obousměrný iterátor, který řeší umístění úspěšné poslední prvek v obráceném list směru (umístění, které předchází prvnímu prvku v unreversed list).

Poznámky

crend se používá s obráceným seznamem stejně, jako list::end se používá s list.

S návratovou crendhodnotou objektu list nelze změnit.

crend lze použít k otestování, zda reverzní iterátor dosáhl konce jeho list.

Hodnota vrácená crend hodnotou by neměla být dereferenced.

Příklad

// 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 celého čísla se znaménkem, který lze použít k reprezentaci počtu prvků seznamu v rozsahu mezi prvky, na které odkazují iterátory.

typedef typename Allocator::difference_type difference_type;

Poznámky

Jedná se difference_type o typ vrácený při odečtení nebo zvýšení prostřednictvím iterátorů kontejneru. Obvykle difference_type se používá k reprezentaci počtu prvků v rozsahu [ first, last) mezi iterátory first a last, zahrnuje prvek, na který first odkazuje, a rozsah prvků až do, ale nikoli včetně, prvek, na který lastodkazuje .

Všimněte si, že ačkoli difference_type je k dispozici pro všechny iterátory, které splňují požadavky vstupního iterátoru, který zahrnuje třídu obousměrných iterátorů podporovaných reverzibilními kontejnery, jako je sada, odčítání mezi iterátory je podporováno pouze iterátory náhodného přístupu poskytované kontejnerem náhodného přístupu, jako vector je třída.

Příklad

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

Vloží prvek vytvořený na místě do seznamu na určené pozici.

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

Parametry

Where
Pozice v cíli list , kde je vložen první prvek.

val
Prvek přidaný na konec list.

Poznámky

Pokud dojde k vyvolání výjimky, list zůstane nezachovaná a výjimka se znovu zobrazí.

Příklad

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

Přidá prvek vytvořený na místě na konec seznamu.

void emplace_back(Type&& val);

Parametry

val
Prvek přidaný na konec list.

Poznámky

Pokud dojde k vyvolání výjimky, list zůstane nezachovaná a výjimka se znovu zobrazí.

Příklad

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

Přidá prvek vytvořený na místě na začátek seznamu.

void emplace_front(Type&& val);

Parametry

val
Prvek přidaný na začátek list.

Poznámky

Pokud dojde k vyvolání výjimky, list zůstane nezachovaná a výjimka se znovu zobrazí.

Příklad

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

Testuje, jestli je seznam prázdný.

bool empty() const;

Vrácená hodnota

true je-li seznam prázdný; false pokud seznam není prázdný.

Příklad

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

Vrátí iterátor adresující umístění úspěšného posledního prvku v seznamu.

const_iterator end() const;
iterator end();

Vrácená hodnota

Obousměrný iterátor, který řeší umístění úspěšné poslední prvek v seznamu. Pokud je seznam prázdný, pak list::end == list::begin.

Poznámky

end slouží k otestování, jestli iterátor dosáhl konce seznamu.

Příklad

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

Odebere prvek nebo rozsah prvků v seznamu ze zadaných pozic.

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

Parametry

Where
Pozice prvku, který se má odebrat ze seznamu.

first
Pozice prvního prvku odebraného ze seznamu

last
Pozice těsně za posledním prvkem odebranými ze seznamu

Vrácená hodnota

Obousměrný iterátor, který určuje první prvek, který zůstává nad rámec všech odebraných prvků, nebo ukazatel na konec seznamu, pokud žádný takový prvek neexistuje.

Poznámky

Nedojde k žádné relokaci, takže iterátory a odkazy se stanou neplatnými pouze pro odstraněné prvky.

erase nikdy nevyvolá výjimku.

Příklad

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

Vrátí odkaz na první prvek v seznamu.

reference front();
const_reference front() const;

Vrácená hodnota

Pokud je seznam prázdný, návrat není definován.

Poznámky

Pokud je vrácená hodnota front přiřazena k objektu const_referenceseznamu, nelze upravit objekt seznamu. Pokud je vrácená hodnota front přiřazena k objektu referenceseznamu, lze upravit objekt seznamu.

Příklad

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

Vrátí kopii objektu alokátoru použitého k vytvoření seznamu.

Allocator get_allocator() const;

Vrácená hodnota

Alokátor používaný seznamem.

Poznámky

Alokátory pro třídu seznamu určují, jak třída spravuje úložiště. Výchozí alokátory dodávané s třídami kontejneru standardní knihovny C++ jsou dostatečné pro většinu programovacích potřeb. Psaní a používání vlastní třídy alokátoru je pokročilé téma jazyka C++.

Příklad

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

Vloží prvek nebo počet prvků nebo rozsah prvků do seznamu na zadané pozici.

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
Pozice v cílovém seznamu, kde je vložen první prvek.

Val
Hodnota prvku vloženého do seznamu.

Count
Počet prvků, které se vkládají do seznamu.

First
Pozice prvního prvku v oblasti prvků v seznamu argumentů, který se má zkopírovat.

Last
Pozice prvního prvku nad rozsah prvků v seznamu argumentů, který se má zkopírovat.

Vrácená hodnota

První dvě funkce vložení vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do seznamu.

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst nebo upravovat libovolný prvek v seznamu.

typedef implementation-defined iterator;

Poznámky

Typ iterator lze použít k úpravě hodnoty elementu.

Příklad

Podívejte se na příklad pro begin.

`list`

Vytvoří seznam určité velikosti nebo s prvky určité hodnoty nebo s určitým alokátorem nebo jako kopii celého nebo části některého jiného seznamu.

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
Třída alokátoru, která se má použít s tímto objektem.

Count
Počet prvků v seznamu vytvořených.

Val
Hodnota prvků v seznamu.

Right
Seznam, ze kterého má být vytvořený seznam kopií.

First
Pozice prvního prvku v oblasti prvků, které se mají zkopírovat.

Last
Pozice prvního prvku nad rozsah prvků, které se mají zkopírovat.

IList
Initializer_list obsahující prvky, které se mají zkopírovat.

Poznámky

Všechny konstruktory ukládají objekt alokátoru (Al) a inicializují seznam.

get_allocator vrátí kopii objektu alokátoru použitého k vytvoření seznamu.

První dva konstruktory určují prázdný počáteční seznam, druhý určující typ alokátoru (Al), který se má použít.

Třetí konstruktor určuje opakování zadaného počtu (Count) prvků výchozí hodnoty pro třídu Type.

Čtvrtý a pátý konstruktor určuje opakování (Count) prvků hodnoty Val.

Šestý konstruktor určuje kopii seznamu Right.

Sedmý konstruktor přesune seznam Right.

Osmý konstruktor používá k určení prvků objekt initializer_list.

Další dva konstruktory zkopírují rozsah [First, Last) seznamu.

Žádná z konstruktorů neprovede žádné dočasné relokace.

Příklad

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

Vrátí maximální délku seznamu.

size_type max_size() const;

Vrácená hodnota

Maximální možná délka seznamu.

Příklad

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

Odebere prvky ze seznamu argumentů, vloží je do cílového seznamu a objedná novou sloučenou sadu prvků ve vzestupném pořadí nebo v jiném zadaném pořadí.

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

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

Parametry

right
Seznam argumentů, který se má sloučit s cílovým seznamem.

comp
Relační operátor použitý k seřazení prvků cílového seznamu.

Poznámky

Seznam right argumentů se sloučí s cílovým seznamem.

Argumenty i cílové seznamy musí být seřazeny se stejným relačním vztahem, podle kterého má být výsledná sekvence seřazena. Výchozí pořadí první členské funkce je vzestupné. Druhá členová funkce ukládá operaci compTraitsporovnání třídy zadanou uživatelem .

Příklad

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

Nahradí prvky seznamu kopií jiného seznamu.

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

Parametry

right
Zkopírovaná list do souboru list.

Poznámky

Po vymazání všech existujících prvků v operátor listbuď zkopíruje nebo přesune obsah right do list.

Příklad

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

Poskytuje ukazatel na prvek v seznamu.

typedef typename Allocator::pointer pointer;

Poznámky

Typ pointer lze použít k úpravě hodnoty elementu.

Ve většině případů iterator by se měla použít pro přístup k prvkům v objektu seznamu.

`pop_back`

Odstraní prvek na konci seznamu.

void pop_back();

Poznámky

Poslední prvek nesmí být prázdný. pop_back nikdy nevyvolá výjimku.

Příklad

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

Odstraní prvek na začátku seznamu.

void pop_front();

Poznámky

První prvek nesmí být prázdný. pop_front nikdy nevyvolá výjimku.

Příklad

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

Přidá prvek na konec seznamu.

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

Parametry

val
Prvek přidaný na konec seznamu.

Poznámky

Pokud dojde k vyvolání výjimky, seznam zůstane nezachovaný a výjimka se znovu zobrazí.

Příklad

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

Přidá prvek na začátek seznamu.

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

Parametry

val
Prvek přidaný na začátek seznamu.

Poznámky

Pokud dojde k vyvolání výjimky, seznam zůstane nezachovaný a výjimka se znovu zobrazí.

Příklad

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

Vrátí iterátor, který řeší první prvek v obráceném seznamu.

const_reverse_iterator rbegin() const;
reverse_iterator rbegin();

Vrácená hodnota

Reverzní obousměrný iterátor adresovaný prvním prvkem v obráceném seznamu (nebo adresování posledního prvku v nereverzním seznamu).

Poznámky

rbegin se používá s obráceným seznamem stejně, jako begin se používá se seznamem.

Pokud je vrácená hodnota rbegin přiřazena k objektu const_reverse_iteratorseznamu, nelze upravit objekt seznamu. Pokud je vrácená hodnota rbegin přiřazena k objektu reverse_iteratorseznamu, lze upravit objekt seznamu.

rbegin lze použít k iteraci seznamu zpět.

Příklad

// 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, který poskytuje odkaz na prvek uložený v seznamu.

typedef typename Allocator::reference reference;

Příklad

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

Vymaže prvky v seznamu, které odpovídají zadané hodnotě.

void remove(const Type& val);

Parametry

val
Hodnota, která je uložena elementem, způsobí odebrání tohoto prvku ze seznamu.

Poznámky

Pořadí zbývajících prvků není ovlivněno.

Příklad

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

Vymaže prvky ze seznamu, pro který je zadaný predikát splněn.

template <class Predicate>
void remove_if(Predicate pred)

Parametry

pred
Unární predikát, který, pokud je splněn prvkem, vede k odstranění tohoto prvku ze seznamu.

Příklad

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

Vrátí iterátor adresovaný umístění, které následuje za posledním prvkem v obráceném seznamu.

const_reverse_iterator rend() const;
reverse_iterator rend();

Vrácená hodnota

Reverzní obousměrný iterátor, který řeší umístění úspěšné poslední prvek v obráceném seznamu (umístění, které předchází prvnímu prvku v nereverzním seznamu).

Poznámky

rend se používá s obráceným seznamem stejně, jako end se používá se seznamem.

Pokud je vrácená hodnota rend přiřazena k objektu const_reverse_iteratorseznamu, nelze upravit objekt seznamu. Pokud je vrácená hodnota rend přiřazena k objektu reverse_iteratorseznamu, lze upravit objekt seznamu.

rend lze použít k otestování, zda reverzní iterátor dosáhl konce seznamu.

Hodnota vrácená rend hodnotou by neměla být dereferenced.

Příklad

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

Určuje novou velikost seznamu.

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

Parametry

_Newsize
Nová velikost seznamu.

val
Hodnota nových prvků, které se mají přidat do seznamu, pokud je nová velikost větší než původní velikost. Pokud je hodnota vynechána, nové prvky jsou přiřazeny výchozí hodnotu pro třídu.

Poznámky

Pokud je velikost seznamu menší než požadovaná velikost, přidají se do seznamu prvky, _Newsizedokud nedosáhne požadované velikosti.

Pokud je velikost seznamu větší než požadovaná velikost, odstraní se prvky nejblíže ke konci seznamu, dokud seznam nedosáhne velikosti _Newsize.

Pokud je aktuální velikost seznamu stejná jako požadovaná velikost, neprovádí se žádná akce.

size zobrazuje aktuální velikost seznamu.

Příklad

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

Vrátí pořadí, ve kterém se prvky vyskytují v seznamu.

void reverse();

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst nebo upravovat prvek v obráceném seznamu.

typedef std::reverse_iterator<iterator> reverse_iterator;

Poznámky

Typ reverse_iterator se používá k iteraci v seznamu obráceně.

Příklad

Podívejte se na příklad pro rbegin.

`size`

Vrátí počet prvků v seznamu.

size_type size() const;

Vrácená hodnota

Aktuální délka seznamu.

Příklad

// 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, který spočítá počet prvků v seznamu.

typedef typename Allocator::size_type size_type;

Příklad

Podívejte se na příklad pro size.

`sort`

Uspořádá prvky seznamu ve vzestupném pořadí nebo s ohledem na jiné pořadí zadané uživatelem.

void sort();

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

Parametry

comp
Relační operátor použitý k seřazení po sobě jdoucích prvků.

Poznámky

První člen funkce ve výchozím nastavení umístí prvky ve vzestupném pořadí.

Funkce členské šablony objednává prvky podle uživatelem zadané porovnávací operace comp třídy Traits.

Příklad

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

Odebere prvky ze zdrojového seznamu a vloží je do cílového seznamu.

// 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
Pozice v cílovém seznamu, před kterou chcete vložit.

Source
Zdrojový seznam, který se má vložit do cílového seznamu.

Iter
Prvek, který se má vložit ze zdrojového seznamu.

First
První prvek v oblasti, která se má vložit ze zdrojového seznamu.

Last
První pozice za posledním prvkem v oblasti, která se má vložit ze zdrojového seznamu.

Poznámky

První dvojice členských funkcí vloží všechny prvky ze zdrojového seznamu do cílového seznamu před pozici, na kterou Where odkazuje, a odebere všechny prvky ze zdrojového seznamu. (&Source nesmí být rovno this.)

Druhá dvojice členských funkcí vloží prvek odkazovaný Iter před pozici v cílovém seznamu, na který Where odkazuje, a odebere Iter ze zdrojového seznamu. (Pokud Where == Iter || Where == ++Iternedojde k žádné změně.)

Třetí dvojice členských funkcí vloží oblast určenou [ First, Last) před prvek v cílovém seznamu, na který Where odkazuje, a odebere tento rozsah prvků ze zdrojového seznamu. (Pokud &Source == thisoblast [First, Last) nesmí obsahovat prvek, na který Whereodkazuje .)

Pokud rozsah splice vloží N prvky, a &Source != this, objekt třídy iterator se zvýší N časy.

Ve všech případech zůstávají iterátory, ukazatele nebo odkazy odkazující na duplicitní prvky platné a přenesou se do cílového kontejneru.

Příklad

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

Vymění prvky dvou seznamů.

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

Parametry

right
Seznam poskytující prvky, které mají být prohozeny, nebo seznam, jehož prvky mají být vyměňovány s prvky seznamu left.

left
Seznam, jehož prvky mají být vyměňovány s prvky seznamu right.

Příklad

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

Odebere sousední duplicitní prvky nebo sousední prvky, které splňují některé jiné binární predikáty ze seznamu.

void unique();

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

Parametry

pred
Binární predikát použitý k porovnání po sobě jdoucích prvků.

Poznámky

Tato funkce předpokládá, že seznam je seřazený tak, aby všechny duplicitní prvky sousedily. Duplicitní položky, které nejsou vedle sebe, nebudou odstraněny.

První člen funkce odebere každý prvek, který porovnává stejné s předchozím prvkem.

Druhá členská funkce odebere všechny prvky, které splňují predikát funkce pred ve srovnání s předchozím prvkem. Pro argument pred můžete použít kterýkoli z objektů binární funkce deklarovaných v <functional> záhlaví nebo můžete vytvořit vlastní.

Příklad

// 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, který představuje datový typ uložený v seznamu.

typedef typename Allocator::value_type value_type;

Poznámky

value_type je synonymem parametru Typešablony .

Příklad

// 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 Třída

Syntaxe

Parametry

Poznámky

Členové

Konstruktory

Typedefs

Funkce

Operátory

Požadavky

allocator_type

Poznámky

Příklad

assign

Parametry

Poznámky

Příklad

back

Vrácená hodnota

Poznámky

Příklad

begin

Vrácená hodnota

Poznámky

Příklad

cbegin

Vrácená hodnota

Poznámky

cend

Vrácená hodnota

Poznámky

Jasné

Příklad

const_iterator

Poznámky

Příklad

const_pointer

Poznámky

const_reference

Poznámky

Příklad

const_reverse_iterator

Poznámky

Příklad

crbegin

Vrácená hodnota

Poznámky

Příklad

crend

Vrácená hodnota

Poznámky

Příklad

difference_type

Poznámky

Příklad

emplace

Parametry

Poznámky

Příklad

emplace_back

Parametry

Poznámky

Příklad

emplace_front

Parametry

Poznámky

Příklad

empty

Vrácená hodnota

Příklad

end

Vrácená hodnota

Poznámky

Příklad

erase

Parametry

Vrácená hodnota

Poznámky

Příklad

front

`list` Třída

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