forward_list – třída

Článek
04/03/2024

Popisuje objekt, který řídí různou sekvenci délky prvků. Sekvence je uložena jako ingly propojený seznam uzlů, z nichž každý obsahuje člena typu Type.

Syntaxe

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

Parametry

Typ*
Datový typ elementu, který má být uložen v forward_list.

Přidělování
Uložený objekt alokátoru, který zapouzdřuje podrobnosti o přidělení forward_list a uvolnění paměti. Tento parametr je volitelný. Výchozí hodnota je alokátor<Type>.

Poznámky

Objekt forward_list přiděluje a uvolní úložiště pro sekvenci, kterou řídí prostřednictvím uloženého objektu alokátoru třídy, který je založen na třídě alokátoru (běžně označované jako std::allocator). Další informace naleznete v tématu Alokátory. Objekt alokátoru musí mít stejné externí rozhraní jako objekt typu allocator.

Poznámka:

Uložený objekt alokátoru se při přiřazení objektu kontejneru nezkopíruje.

Iterátory, ukazatele a odkazy mohou být neplatné, když jsou prvky jejich řízené sekvence vymazány .forward_list Vložení a splicy prováděné s kontrolovanou sekvencí prostřednictvím forward_list neplatných iterátorů.

K přidání řízené sekvence může dojít voláním forward_list ::insert_after, což je jediná členová funkce, která volá konstruktor Type(const T&). forward_list může také volat konstruktory přesunutí. Pokud takový výraz vyvolá výjimku, objekt kontejneru vloží žádné nové prvky a znovu vytvoří výjimku. Objekt typu forward_list je tedy ponechán ve známém stavu, pokud k těmto výjimkám dojde.

Členové

Konstruktory

Název	Popis
forward_list	Vytvoří objekt typu `forward_list`.

Typedefs

Název	Popis
allocator_type	Typ, který představuje třídu alokátoru pro objekt forward list.
const_iterator	Typ, který poskytuje konstantní iterátor pro seznam vpřed.
const_pointer	Typ, který poskytuje ukazatel na `const` prvek v seznamu vpřed.
const_reference	Typ, který poskytuje konstantní odkaz na prvek v seznamu vpřed.
difference_type	Typ celého čísla se znaménkem, který lze použít k reprezentaci počtu prvků přeposlaného seznamu v rozsahu mezi prvky, na které odkazují iterátory.
Iterace	Typ, který poskytuje iterátor pro seznam vpřed.
Ukazatel	Typ, který poskytuje ukazatel na prvek v seznamu vpřed.
Odkaz	Typ, který poskytuje odkaz na prvek v předávacím seznamu.
size_type	Typ, který představuje nepodepsanou vzdálenost mezi dvěma prvky.
value_type	Typ, který představuje typ elementu uloženého v seznamu vpřed.

Functions

Název	Popis
Přiřadit	Vymaže prvky z přeposílaného seznamu a zkopíruje novou sadu prvků do cílového přeposlání seznamu.
before_begin	Vrátí iterátor adresovaný pozici před prvním prvkem v seznamu vpřed.
Začít	Vrátí iterátor adresovaný prvním prvkem v seznamu vpřed.
cbefore_begin	Vrátí konstantní iterátor adresovaný pozici před prvním prvkem v dopředu seznamu.
cbegin	Vrátí konstantní iterátor adresovaný prvním prvkem v seznamu vpřed.
cend	Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v předávacího seznamu.
Jasné	Vymaže všechny prvky přeposílání seznamu.
emplace_after	Přesunutí vytvoří nový prvek za zadanou pozicí.
emplace_front	Přidá prvek vytvořený na místě na začátek seznamu.
empty	Testuje, jestli je seznam pro předávání prázdný.
Konec	Vrátí iterátor, který bude adresovat umístění úspěšné poslední prvek v předávacího seznamu.
erase_after	Odebere prvky ze seznamu vpřed za zadanou pozicí.
Přední	Vrátí odkaz na první prvek v předávacím seznamu.
get_allocator	Vrátí kopii objektu alokátoru použitého k vytvoření předaného seznamu.
insert_after	Přidá prvky do seznamu vpřed za zadanou pozici.
max_size	Vrátí maximální délku přeposílání seznamu.
Sloučit	Odebere prvky ze seznamu argumentů, vloží je do cílového forward seznamu a objedná novou sloučenou sadu prvků ve vzestupném pořadí nebo v jiném zadaném pořadí.
pop_front	Odstraní prvek na začátku přeposílání seznamu.
push_front	Přidá prvek na začátek přeposílání seznamu.
remove	Vymaže prvky v přeposílání seznamu, který odpovídá zadané hodnotě.
remove_if	Vymaže prvky ze seznamu dopředu, pro který je zadaný predikát splněn.
Změnit velikost	Určuje novou velikost pro přeposílání seznamu.
reverse	Obrátí pořadí, ve kterém se prvky vyskytují v seznamu vpřed.
sort	Uspořádá prvky vzestupně nebo podle pořadí určeného predikátem.
splice_after	Restitches propojení mezi uzly.
Swap	Vymění prvky dvou přeposlaných seznamů.
unique	Odebere sousední prvky, které projdou zadaným testem.

Operátory

Název	Popis
operator=	Nahradí prvky přeposílaného seznamu kopií jiného přeposílání seznamu.

allocator_type

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

typedef Allocator allocator_type;

Poznámky

allocator_type je synonymem parametru šablony Allocator.

přiřadit

Vymaže prvky z přeposílaného seznamu a zkopíruje novou sadu prvků do cílového přeposlání 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

První
Začátek náhradního rozsahu.

Poslední
Konec náhradního rozsahu.

count
Počet prvků, které se mají přiřadit.

Val
Hodnota, která má přiřadit každý prvek.

Typ
Typ hodnoty

IList
Initializer_list ke zkopírování.

Poznámky

Pokud je forward_list celočíselnou typ, první členová funkce se chová stejně jako assign((size_type)First, (Type)Last). Jinak první členová funkce nahradí sekvenci řízenou *this sekvencí [ First, Last), která nesmí překrývat počáteční řízenou sekvenci.

Druhá členová funkce nahrazuje sekvenci řízenou opakováním *thisCount prvků hodnoty Val.

Třetí člen funkce zkopíruje prvky initializer_list do forward_list.

before_begin

Vrátí iterátor adresovaný pozici před prvním prvkem v seznamu vpřed.

const_iterator before_begin() const;
iterator before_begin();

Návratová hodnota

Dopředu iterátor, který odkazuje těsně před prvním prvkem sekvence (nebo těsně před koncem prázdné sekvence).

Poznámky

Začít

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

const_iterator begin() const;
iterator begin();

Návratová hodnota

Iterátor vpřed, který odkazuje na první prvek sekvence (nebo těsně za koncem prázdné sekvence).

Poznámky

cbefore_begin

Vrátí konstantní iterátor adresovaný pozici před prvním prvkem v dopředu seznamu.

const_iterator cbefore_begin() const;

Návratová hodnota

Dopředu iterátor, který odkazuje těsně před prvním prvkem sekvence (nebo těsně před koncem prázdné sekvence).

Poznámky

cbegin

const Vrátí iterátor, který řeší první prvek v oblasti.

const_iterator cbegin() const;

Návratová hodnota

const Iterátor s přístupem vpřed, 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á s klíčovým slovem automatického odpočtu 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;

Návratová hodnota

Iterátor pro dopředný přístup, který ukazuje přesně za konec 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á s klíčovým slovem automatického odpočtu 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 by neměla být dereferenced.

Jasné

Vymaže všechny prvky přeposílání seznamu.

void clear();

Poznámky

Tato členová funkce volá erase_after(before_begin(), end()).

const_iterator

Typ, který poskytuje konstantní iterátor pro seznam vpřed.

typedef implementation-defined const_iterator;

Poznámky

const_iterator popisuje objekt, který může sloužit jako konstantní dopředu iterátor pro řízenou sekvenci. Tady je popsáno jako synonymum pro typ definovaný implementací.

const_pointer

Typ, který poskytuje ukazatel na const prvek v seznamu vpřed.

typedef typename Allocator::const_pointer
    const_pointer;

Poznámky

const_reference

Typ, který poskytuje konstantní odkaz na prvek v seznamu vpřed.

typedef typename Allocator::const_reference const_reference;

Poznámky

difference_type

Typ celého čísla se znaménkem, který lze použít k reprezentaci počtu prvků přeposlaného seznamu v rozsahu mezi prvky, na které odkazují iterátory.

typedef typename Allocator::difference_type difference_type;

Poznámky

difference_type popisuje objekt, který může představovat rozdíl mezi adresami všech dvou prvků v řízené sekvenci.

emplace_after

Přesunutí vytvoří nový prvek za zadanou pozicí.

template <class T>
iterator emplace_after(const_iterator Where, Type&& val);

Parametry

Kde
Pozice v cílovém dopředu seznamu, kde je vytvořen nový prvek.

Val
Argument konstruktoru.

Návratová hodnota

Iterátor, který označuje nově vložený prvek.

Poznámky

Tato členová funkce vloží prvek s argumenty konstruktoru val těsně za prvek, na který odkazuje Wherev řízené sekvenci. Jeho chování je jinak stejné jako forward_list::insert_after.

emplace_front

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

template <class Type>
    void emplace_front(Type&& val);

Parametry

Val
Prvek přidaný na začátek přeposílání seznamu.

Poznámky

Tato členová funkce vloží prvek s argumenty _ val konstruktoru na konec řízené sekvence.

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

empty

Testuje, jestli je seznam pro předávání prázdný.

bool empty() const;

Návratová hodnota

truepokud je seznam pro předávání prázdný; v opačném případě . false

end

Vrátí iterátor, který bude adresovat umístění úspěšné poslední prvek v předávacího seznamu.

const_iterator end() const;
iterator end();

Návratová hodnota

Dopředný iterátor, který odkazuje těsně za koncem sekvence.

erase_after

Odebere prvky ze seznamu vpřed za zadanou pozicí.

iterator erase_after(const_iterator Where);
iterator erase_after(const_iterator first, const_iterator last);

Parametry

Kde
Pozice v cílovém dopředu seznamu, kde je prvek vymazán.

První
Začátek rozsahu, který chcete vymazat.

Poslední
Konec rozsahu, který chcete vymazat.

Návratová hodnota

Iterátor, který určuje první prvek, který zůstává nad rámec všech odebraných prvků, nebo forward_list::end , pokud neexistuje žádný takový prvek.

Poznámky

První člen funkce odebere prvek řízené sekvence hned po Where.

Druhá členová funkce odebere prvky řízené sekvence v oblasti ( first, last) (ani koncový bod není zahrnut).

N Mazání prvků způsobuje N volání destruktoru. Dojde k relokaci , takže iterátory a odkazy se pro odstraněné prvky stanou neplatnými.

Členské funkce nikdy nevyvolají výjimku.

forward_list

Vytvoří objekt typu forward_list.

forward_list();
explicit forward_list(const Allocator& Al);
explicit forward_list(size_type Count);
forward_list(size_type Count, const Type& Val);
forward_list(size_type Count, const Type& Val, const Allocator& Al);
forward_list(const forward_list& Right);
forward_list(const forward_list& Right, const Allocator& Al);
forward_list(forward_list&& Right);
forward_list(forward_list&& Right, const Allocator& Al);
forward_list(initializer_list<Type> IList, const Alloc& Al);
template <class InputIterator>
forward_list(InputIterator First, InputIterator Last);
template <class InputIterator>
forward_list(InputIterator First, InputIterator Last, const Allocator& Al);

Parametry

Al
Třída alokátoru, která se má použít s tímto objektem.

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

Val
Hodnota prvků v seznamu byla vytvořena.

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

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

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

IList
Initializer_list ke zkopírování.

Poznámky

Všechny konstruktory ukládají alokátor a inicializují řízenou sekvenci. Objekt alokátoru je argument Al, pokud je k dispozici. Pro konstruktor kopírování je to right.get_allocator(). Jinak je to Allocator().

První dva konstruktory určují prázdnou počáteční řízenou sekvenci.

Třetí konstruktor určuje opakování count prvků hodnoty Type().

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

Šestý konstruktor určuje kopii sekvence řízené vpravo. Pokud InputIterator je celočíselného typu, další dva konstruktory určují opakování (size_type)First prvků hodnoty (Type)Last. V opačném případě následující dva konstruktory určují sekvenci [First, Last).

Devátá a desátá konstruktor jsou stejná jako šestá, ale s odkazem na rvalue .

Poslední konstruktor určuje počáteční řízenou sekvenci s objektem třídy initializer_list<Type>.

Přední

Vrátí odkaz na první prvek v předávacím seznamu.

reference front();
const_reference front() const;

Návratová hodnota

Odkaz na první prvek řízené sekvence, který musí být neprázdný.

get_allocator

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

allocator_type get_allocator() const;

Návratová hodnota

Uložený objekt alokátoru .

insert_after

Přidá prvky do seznamu vpřed za zadanou pozici.

iterator insert_after(const_iterator Where, const Type& Val);
void insert_after(const_iterator Where, size_type Count, const Type& Val);
void insert_after(const iterator Where, initializer_list<Type> IList);
iterator insert_after(const_iterator Where, Type&& Val);
template <class InputIterator>
    void insert_after(const_iterator Where, InputIterator First, InputIterator Last);

Parametry

Kde
Pozice v cílovém dopředu seznamu, kde je vložen první prvek.

Počet
Počet prvků, které chcete vložit.

První
Začátek oblasti vložení.

Poslední
Konec oblasti vložení.

Val
Prvek přidaný do přeposílání seznamu.

IList
Initializer_list, který chcete vložit.

Návratová hodnota

Iterátor, který určuje nově vložený prvek (pouze první a poslední členské funkce).

Poznámky

Každá z členských funkcí se vloží – hned za prvek, na který odkazuje Where v řízené sekvenci – posloupnost určená zbývajícími operandy.

První člen funkce vloží prvek, který má hodnotu Val a vrátí iterátor, který určuje nově vložený prvek.

Druhá členová funkce vloží opakování prvků count hodnoty Val.

Pokud InputIterator je celočíselná hodnota, třetí členová funkce se chová stejně jako insert(it, (size_type)First, (Type)Last). Jinak vloží sekvenci, která nesmí překrývat počáteční řízenou sekvenci [First, Last).

Čtvrtá členská funkce vloží sekvenci určenou objektem třídy initializer_list<Type>.

Poslední členová funkce je stejná jako první, ale s odkazem na rvalue .

Vkládání N prvků způsobuje N volání konstruktoru. Dojde k relokaci , ale žádné iterátory nebo odkazy nebudou neplatné.

Pokud během vložení jednoho nebo více prvků dojde k výjimce, kontejner zůstane nezachovaný a výjimka se znovu zobrazí.

iterátor

Typ, který poskytuje iterátor pro seznam vpřed.

typedef implementation-defined iterator;

Poznámky

iterator popisuje objekt, který může sloužit jako iterátor pro řízenou sekvenci. Tady je popsáno jako synonymum pro typ definovaný implementací.

max_size

Vrátí maximální délku přeposílání seznamu.

size_type max_size() const;

Návratová hodnota

Délka nejdelší sekvence, kterou může objekt ovládat.

Poznámky

Sloučit

Kombinuje dvě seřazené sekvence do jedné seřazené sekvence v lineárním čase. Odebere prvky ze seznamu argumentů a vloží je do tohoto forward_listsouboru . Dva seznamy by měly být seřazeny podle stejného porovnávaného objektu funkce před voláním merge. Kombinovaný seznam bude seřazen podle objektu porovnávací funkce.

void merge(forward_list& right);
template <class Predicate>
    void merge(forward_list& right, Predicate comp);

Parametry

Právo
Seznam pro přeposlání, ze které chcete sloučit.

Comp
Porovnávací objekt funkce, který se používá k řazení prvků.

Poznámky

forward_list::merge odebere prvky z forward_listrighta vloží je do tohoto forward_list. Obě sekvence musí být seřazeny stejným predikátem, jak je popsáno níže. Kombinovaná sekvence je také seřazena podle toho, že porovnávají objekt funkce.

Pro iterátory a navrhování prvků na pozicích i a jprvní členová funkce ukládá pořadí !(*Pj < *Pi) vždy, když i < j.PjPi (Prvky jsou seřazené v ascending pořadí.) Druhá členová funkce ukládá pořadí ! comp(*Pj, *Pi) vždy, když i < j.

Ve výsledné řízené sekvenci nejsou obrácené žádné dvojice prvků v původní řízené sekvenci. Je-li dvojice prvků ve výsledné řízené sekvenci porovnává rovno ( !(*Pi < *Pj) && !(*Pj < *Pi)), prvek z původní řízené sekvence se zobrazí před prvkem z sekvence řízené right.

K výjimce dojde pouze v případě, že comp vyvolá výjimku. V takovém případě je řízená sekvence ponechána v nezadaném pořadí a výjimka je znovu nalezena.

operator=

Nahradí prvky přeposílaného seznamu kopií jiného přeposílání seznamu.

forward_list& operator=(const forward_list& right);
forward_list& operator=(initializer_list<Type> IList);
forward_list& operator=(forward_list&& right);

Parametry

Právo
Dopředného seznamu, který se kopíruje do předávaného seznamu.

IList
Složený seznam inicializátorů uzavřený s složenou závorkou, který se chová stejně jako posloupnost prvků typu Type.

Poznámky

První člen operátor nahrazuje řízenou sekvenci kopií sekvence řízené vpravo.

Druhý člen operátor nahrazuje řízenou sekvenci z objektu třídy initializer_list<Type>.

Třetí operátor členu je stejný jako první, ale s odkazem na rvalue .

ukazatel

Typ, který poskytuje ukazatel na prvek v seznamu vpřed.

typedef typename Allocator::pointer pointer;

pop_front

Odstraní prvek na začátku přeposílání seznamu.

void pop_front();

Poznámky

První prvek předávaného seznamu musí být neprázdný.

Členová funkce nikdy nevyvolá výjimku.

push_front

Přidá prvek na začátek přeposílání seznamu.

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

Parametry

Val
Prvek přidaný na začátek přeposílání seznamu.

Poznámky

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

reference

Typ, který poskytuje odkaz na prvek v předávacím seznamu.

typedef typename Allocator::reference reference;

remove

Vymaže prvky v přeposílání seznamu, který odpovídá 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

Členová funkce odebere z řízené sekvence všechny prvky určené iterátorem P, pro které *P == val.

Členová funkce nikdy nevyvolá výjimku.

remove_if

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

template <class Predicate>
    void remove_if(Predicate pred);

Parametry

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

Poznámky

Členová funkce odebere z řízené sekvence všechny prvky určené iterátorem P, pro který pred(*P) je pravda.

K výjimce dochází pouze v případě, že před vyvolání výjimky. V takovém případě je řízená sekvence ponechána v nezadaném stavu a výjimka se znovu zřetědí.

změna velikosti

Určuje novou velikost pro přeposílání seznamu.

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

Parametry

_Newsize
Počet prvků v seznamu pro přeposlání se změněnou velikostí

Val
Hodnota, kterou chcete použít pro odsazení.

Poznámky

Členské funkce zajišťují, že počet prvků v seznamu je _Newsize. Pokud musí být řízená sekvence delší, první členová funkce připojí prvky s hodnotou Type(), zatímco druhá členová funkce připojí prvky s hodnotou val. Aby byla řízená sekvence kratší, obě členské funkce efektivně volají erase_after(begin() + _Newsize - 1, end()).

reverse

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

void reverse();

size_type

Typ, který představuje nepodepsanou vzdálenost mezi dvěma prvky.

typedef typename Allocator::size_type size_type;

Poznámky

Typ celého čísla bez znaménka popisuje objekt, který může představovat délku libovolné řízené sekvence.

sort

Uspořádá prvky vzestupně nebo podle pořadí určeného predikátem.

void sort();
template <class Predicate>
void sort(Predicate pred);

Parametry

před
Predikát řazení.

Poznámky

Obě členské funkce pořadí prvků v řízené sekvenci podle predikátu, jak je popsáno níže.

Pro iterátory a navrhování prvků na pozicích i a jprvní členová funkce ukládá pořadí !(*Pj < *Pi) vždy, když i < j.PjPi (Prvky jsou seřazené v ascending pořadí.) Funkce šablony člena ukládá pořadí ! pred(*Pj, *Pi) vždy, když i < j. Ve výsledné řízené sekvenci nejsou obrácené žádné seřazené dvojice prvků v původní řízené sekvenci. (Řazení je stabilní.)

K výjimce dochází pouze v případě, že před vyvolání výjimky. V takovém případě je řízená sekvence ponechána v nezadaném pořadí a výjimka je znovu nalezena.

splice_after

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

// insert the entire source forward_list
void splice_after(const_iterator Where, forward_list& Source);
void splice_after(const_iterator Where, forward_list&& Source);

// insert one element of the source forward_list
void splice_after(const_iterator Where, forward_list& Source, const_iterator Iter);
void splice_after(const_iterator Where, forward_list&& Source, const_iterator Iter);

// insert a range of elements from the source forward_list
void splice_after(
    const_iterator Where,
    forward_list& Source,
    const_iterator First,
    const_iterator Last);

void splice_after(
    const_iterator Where,
    forward_list&& Source,
    const_iterator First,
    const_iterator Last);

Parametry

Kde
Umístění v cílovém forward_list, po kterém se má vložit.

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

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

První
První prvek v oblasti, která má být vložena ze zdrojového forward_list.

Poslední
První pozice nad rozsah, který se má vložit ze zdrojového forward_list.

Poznámky

První dvojice členských funkcí vloží sekvenci řízenou zdrojem těsně za prvek v řízené sekvenci odkazované na Where. Odebere také všechny prvky ze zdroje. (&Source nesmí být rovno this.)

Druhá dvojice členských funkcí odebere prvek těsně po Iteru v sekvenci řízené zdrojem a vloží ho těsně za prvek v řízené sekvenci, na kterou odkazuje Where. (Pokud Where == Iter || Where == ++Iternedojde k žádné změně.)

Třetí dvojice členských funkcí (ranged splice) vloží dílčí uspořádání určené (First, Last) ze sekvence řízené zdrojem těsně za prvek v řízené sekvenci odkazované na Where. Odebere také původní dílčí uspořádání ze sekvence řízené zdrojem. (Pokud &Source == thisrozsah (First, Last) nesmí obsahovat prvek, na který odkazuje Where.)

Pokud rozsah splice vloží N prvky, a &Source != this, objekt iterátor třídy je přírůstku N krát.

Neplatné nejsou iterátory, ukazatele ani odkazy, které označují duplicitní prvky.

Příklad

// forward_list_splice_after.cpp
// compile with: /EHsc /W4
#include <forward_list>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

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

    forward_list<int>::iterator where_iter;
    forward_list<int>::iterator first_iter;
    forward_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_after(where_iter, c1);
    cout << "After splicing c1 into c2:" << endl;
    cout << "c1 = ";
    print(c1);
    cout << "c2 = ";
    print(c2);

    first_iter = c3.begin();
    c2.splice_after(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;
    c2.splice_after(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 = (10) (11)c2 = (20) (21) (22)c3 = (30) (31)c4 = (40) (41) (42) (43)After splicing c1 into c2:c1 =c2 = (20) (21) (10) (11) (22)After splicing the first element of c3 into c2:c3 = (30)c2 = (20) (21) (31) (10) (11) (22)After splicing a range of c4 into c2:c4 = (40) (41)c2 = (20) (21) (42) (43) (31) (10) (11) (22)

swap

Vymění prvky dvou přeposlaných seznamů.

void swap(forward_list& right);

Parametry

Právo
Seznam předávání poskytující prvky, které se mají vyměnit.

Poznámky

Členová funkce prohodí řízené sekvence mezi *this a vpravo. Pokud get_allocator() == right.get_allocator()to provede v konstantním čase, vyvolá žádné výjimky a zneplatní žádné odkazy, ukazatele nebo iterátory, které označují prvky ve dvou kontrolovaných sekvencích. V opačném případě provádí přiřazení prvků a konstruktor volá proporcionální počet prvků ve dvou kontrolovaných sekvencích.

unique

Eliminuje všechny prvky kromě prvního prvku z každé po sobě jdoucí skupiny stejných prvků.

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

Parametry

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

Poznámky

Zachová první z každého jedinečného prvku a odebere zbytek. Prvky musí být seřazené tak, aby prvky se stejnou hodnotou byly v seznamu sousední.

První člen funkce odebere z řízené sekvence každý prvek, který porovnává stejné s předchozím prvkem. Pro iterátory Pi a Pj navrhování prvků na pozicích i a jdruhá členová funkce odebere každý prvek, pro který i + 1 == j && comp(*Pi, *Pj).

Pro řízenou sekvenci délky N (> 0) se predikát comp(*Pi, *Pj) vyhodnocuje N - 1 časy.

K výjimce dojde pouze v případě, že comp vyvolá výjimku. V takovém případě je řízená sekvence ponechána v nezadaném stavu a výjimka se znovu zřetědí.

value_type

Typ, který představuje typ elementu uloženého v seznamu vpřed.

typedef typename Allocator::value_type value_type;

Poznámky

Typ je synonymem pro parametr Typešablony .

Sdílet prostřednictvím

forward_list – třída

Syntaxe

Parametry

Poznámky

Členové

Konstruktory

Typedefs

Functions

Operátory

allocator_type

Poznámky

přiřadit

Parametry

Poznámky

before_begin

Návratová hodnota

Poznámky

Začít

Návratová hodnota

Poznámky

cbefore_begin

Návratová hodnota

Poznámky

cbegin

Návratová hodnota

Poznámky

cend

Návratová hodnota

Poznámky

Jasné

Poznámky

const_iterator

Poznámky

const_pointer

Poznámky

const_reference

Poznámky

difference_type

Poznámky

emplace_after

Parametry

Návratová hodnota

Poznámky

emplace_front

Parametry

Poznámky

empty

Návratová hodnota

end

Návratová hodnota

erase_after

Parametry

Návratová hodnota

Poznámky

forward_list

Parametry

Poznámky

Přední

Návratová hodnota

get_allocator

Návratová hodnota

insert_after

Parametry

Návratová hodnota

Poznámky

iterátor

Poznámky

max_size

Návratová hodnota

Poznámky

Sloučit

Parametry

Poznámky

operator=

Parametry

Poznámky

ukazatel

pop_front

Poznámky