forward_list-klass

Beskriver ett objekt som styr en sekvens med varierande längd av element. Sekvensen lagras som en singly-länkad lista över noder som var och en innehåller en medlem av typen Type.

Syntax

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

Parameterar

Type
Den elementdatatyp som ska lagras i forward_list.

Allocator
Det lagrade allokeringsobjektet som kapslar in information om forward_list allokering och frigöring av minne. Den här parametern är valfri. Standardvärdet är allokeraren<Type>.

Anmärkningar

Ett forward_list objekt allokerar och frigör lagring för den sekvens som det styr genom ett lagrat objekt i klassen Allocator som är baserat på allocator klass (kallas ofta std::allocator). Mer information finns i Allokerare. Ett allokeringsobjekt måste ha samma externa gränssnitt som ett objekt av typen allocator.

Iteratorer, pekare och referenser kan bli ogiltiga när element i deras kontrollerade sekvens raderas via forward_list. Infogningar och skarvar som utförs på den kontrollerade sekvensen genom forward_list ogiltigförklarar inte iteratorer.

Tillägg till den kontrollerade sekvensen kan ske genom anrop till forward_list::insert_after, vilket är den enda medlemsfunktionen som anropar konstruktorn Type(const T&). forward_list kan också anropa flyttkonstruktorer. Om ett sådant uttryck utlöser ett undantag infogar containerobjektet inga nya element och återaktiver undantaget. Därför lämnas ett objekt av typen forward_list i ett känt tillstånd när sådana undantag inträffar.

Medlemmar

Konstruktörer

Typedefs

Funktionen

Operatörer

allocator_type

En typ som representerar allokeringsklassen för ett objekt i en vidarebefordranlista.

typedef Allocator allocator_type;

Anmärkningar

allocator_type är synonymt med mallparametern Allocator.

assign

Raderar element från en framåtriktad lista och kopierar en ny uppsättning element till en framåtriktad mållista.

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

void assign(
    initializer_list<Type> IList);

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

Parameterar

first
Början av ersättningsintervallet.

last
Slutet av ersättningsintervallet.

count
Antalet element som ska tilldelas.

val
Värdet som varje element ska tilldelas.

Type
Typ av värde.

IList
Att initializer_list kopiera.

Anmärkningar

forward_list Om är en heltalstyp fungerar den första medlemsfunktionen på samma sätt som assign((size_type)First, (Type)Last). I annat fall ersätter den första medlemsfunktionen sekvensen som styrs av *this med sekvensen [ First, Last), som inte får överlappa den inledande kontrollerade sekvensen.

Den andra medlemsfunktionen ersätter sekvensen som styrs av *this med en upprepning av Count element av värdet Val.

Den tredje medlemsfunktionen kopierar elementen initializer_list i till forward_list.

before_begin

Returnerar en iterator som adresserar positionen före det första elementet i en vidarebefordranlista.

const_iterator before_begin() const;
iterator before_begin();

Returvärde

En vidarebefordrande iterator som pekar precis före det första elementet i sekvensen (eller precis före slutet av en tom sekvens).

begin

Returnerar en iterator som adresserar det första elementet i en vidarebefordranlista.

const_iterator begin() const;
iterator begin();

Returvärde

En vidarebefordrande iterator som pekar på det första elementet i sekvensen (eller precis utanför slutet av en tom sekvens).

cbefore_begin

Returnerar en const iterator som adresserar positionen före det första elementet i en vidarebefordranlista.

const_iterator cbefore_begin() const;

Returvärde

En vidarebefordrande iterator som pekar precis före det första elementet i sekvensen (eller precis före slutet av en tom sekvens).

cbegin

Returnerar en const iterator som adresserar det första elementet i intervallet.

const_iterator cbegin() const;

Returvärde

En const iterator för vidarebefordran som pekar på det första elementet i intervallet, eller platsen precis utanför slutet av ett tomt intervall (för ett tomt intervall cbegin() == cend()).

Anmärkningar

Med returvärdet för cbeginkan elementen i intervallet inte ändras.

Du kan använda den här medlemsfunktionen i stället för funktionen begin() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det med nyckelordet auto typavdrag, som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder begin() och cbegin().

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

cend

Returnerar en const iterator som adresserar platsen precis utanför det sista elementet i ett intervall.

const_iterator cend() const;

Returvärde

En iterator för vidarebefordran som pekar precis utanför intervallets slut.

Anmärkningar

cend används för att testa om en iterator har passerat slutet av sitt intervall.

Du kan använda den här medlemsfunktionen i stället för funktionen end() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det med nyckelordet auto typavdrag, som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder end() och cend().

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

// i2 is Container<T>::const_iterator

Värdet som returneras av cend ska inte derefereras.

clear

Raderar alla element i en framåtriktad lista.

void clear();

Anmärkningar

Den här medlemsfunktionen anropar erase_after(before_begin(), end()).

const_iterator

En typ som ger en konstant iterator för listan över vidarebefordran.

typedef implementation-defined const_iterator;

Anmärkningar

const_iterator beskriver ett objekt som kan fungera som en konstant vidarebefordran iterator för den kontrollerade sekvensen. Det beskrivs här som en synonym för en implementeringsdefinierad typ.

const_pointer

En typ som ger en pekare till ett const element i en framåtriktad lista.

typedef typename Allocator::const_pointer
    const_pointer;

const_reference

En typ som ger en konstant referens till ett element i listan över vidarebefordran.

typedef typename Allocator::const_reference const_reference;

difference_type

En signerad heltalstyp som kan användas för att representera antalet element i en framåtriktad lista i ett intervall mellan element som iteratorer pekar på.

typedef typename Allocator::difference_type difference_type;

Anmärkningar

difference_type beskriver ett objekt som kan representera skillnaden mellan adresserna för två element i den kontrollerade sekvensen.

emplace_after

Flytta konstruerar ett nytt element efter en angiven position.

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

Parameterar

Where
Positionen i listan över framåtriktade mål där det nya elementet konstrueras.

val
Konstruktorargumentet.

Returvärde

En iterator som anger det nyligen infogade elementet.

Anmärkningar

Den här medlemsfunktionen infogar ett element med konstruktorargumenten val strax efter att elementet pekat på Where i den kontrollerade sekvensen. Dess beteende är annars detsamma som forward_list::insert_after.

emplace_front

Lägger till ett element som skapats på plats i början av listan.

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

Parameterar

val
Elementet har lagts till i början av listan över vidarebefordran.

Anmärkningar

Den här medlemsfunktionen infogar ett element med konstruktorargumenten val i början av den kontrollerade sekvensen.

Om ett undantag utlöses lämnas containern oförändrad och undantaget ändras.

empty

Testar om en vidarebefordrad lista är tom.

bool empty() const;

Returvärde

trueom listan över vidarebefordran är tom; annars . false

end

Returnerar en iterator som adresserar platsen som lyckas med det sista elementet i en vidarebefordranlista.

const_iterator end() const;
iterator end();

Returvärde

En vidarebefordran iterator som pekar precis utanför slutet av sekvensen.

erase_after

Tar bort element från listan framåt efter en angiven position.

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

Parameterar

Where
Positionen i listan över framåtriktade mål där elementet raderas.

first
Början av intervallet som ska raderas.

last
Slutet av intervallet som ska raderas.

Returvärde

En iterator som anger det första elementet som återstår utöver alla element som tas bort, eller forward_list::end om det inte finns något sådant element.

Anmärkningar

Den första medlemsfunktionen tar bort elementet i den kontrollerade sekvensen strax efter Where.

Den andra medlemsfunktionen tar bort elementen i den kontrollerade sekvensen i intervallet ( first, last) (ingen av slutpunkterna ingår).

Radering av N element orsakar N destrueringsanrop. Omfördelning sker, så iteratorer och referenser blir ogiltiga för de borttagna elementen.

Medlemsfunktionerna utlöser aldrig ett undantag.

forward_list

Konstruerar ett objekt av typen 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);

Parameterar

Al
Allokeringsklassen som ska användas med det här objektet.

Count
Antalet element i listan som skapats.

Val
Värdet för elementen i listan som skapats.

Right
Listan som den konstruerade listan ska vara en kopia av.

First
Positionen för det första elementet i området med element som ska kopieras.

Last
Positionen för det första elementet utöver det område av element som ska kopieras.

IList
Att initializer_list kopiera.

Anmärkningar

Alla konstruktorer lagrar en allocator och initierar den kontrollerade sekvensen. Allokeringsobjektet är argumentet Al, om det finns. För kopieringskonstruktorn är right.get_allocator()det . Annars är det Allocator().

De två första konstruktorerna anger en tom inledande kontrollerad sekvens.

Den tredje konstruktorn anger en upprepning av Count element av värdet Type().

De fjärde och femte konstruktorerna anger en upprepning av Count element av värdet Val.

Den sjätte konstruktorn anger en kopia av sekvensen som styrs av Höger. Om InputIterator är en heltalstyp anger nästa två konstruktorer en upprepning av (size_type)First element av värdet (Type)Last. I annat fall anger följande två konstruktorer sekvensen [First, Last).

De nionde och tionde konstruktorerna är samma som den sjätte, men med en rvalue-referens .

Den sista konstruktorn anger den inledande kontrollerade sekvensen med ett objekt av klassen initializer_list<Type>.

front

Returnerar en referens till det första elementet i en vidarebefordranlista.

reference front();
const_reference front() const;

Returvärde

En referens till det första elementet i den kontrollerade sekvensen, som måste vara icke-tom.

get_allocator

Returnerar en kopia av allokeringsobjektet som används för att skapa en vidarebefordrad lista.

allocator_type get_allocator() const;

Returvärde

Det lagrade allocator objektet.

insert_after

Lägger till element i listan framåt efter en angiven position.

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

Parameterar

Where
Positionen i listan över framåtriktade mål där det första elementet infogas.

Count
Antalet element som ska infogas.

First
Början av insättningsintervallet.

Last
Slutet av insättningsintervallet.

Val
Elementet har lagts till i listan över vidarebefordran.

IList
Infoga initializer_list .

Returvärde

En iterator som anger det nyligen infogade elementet (endast första och sista medlemsfunktionerna).

Anmärkningar

Var och en av medlemsfunktionerna infogas – precis efter att elementet pekats på i Where den kontrollerade sekvensen – en sekvens som anges av de återstående operanderna.

Den första medlemsfunktionen infogar ett element som har ett värde Val och returnerar en iterator som anger det nyligen infogade elementet.

Den andra medlemsfunktionen infogar en upprepning av Count element av värdet Val.

Om InputIterator är en heltalstyp fungerar den tredje medlemsfunktionen på samma sätt som insert(it, (size_type)First, (Type)Last). Annars infogas sekvensen [First, Last), som inte får överlappa den inledande kontrollerade sekvensen.

Den fjärde medlemsfunktionen infogar sekvensen som anges av ett objekt av klassen initializer_list<Type>.

Den sista medlemsfunktionen är samma som den första, men med en rvalue-referens .

Infogning av N element orsakar N konstruktoranrop. Omlokalisering sker, men inga iteratorer eller referenser blir ogiltiga.

Om ett undantag utlöses under infogningen av ett eller flera element lämnas containern oförändrad och undantaget ändras.

iterator

En typ som tillhandahåller en iterator för listan över vidarebefordran.

typedef implementation-defined iterator;

Anmärkningar

iterator beskriver ett objekt som kan fungera som en vidarebefordran iterator för den kontrollerade sekvensen. Det beskrivs här som en synonym för en implementeringsdefinierad typ.

max_size

Returnerar den maximala längden för en vidarebefordrad lista.

size_type max_size() const;

Returvärde

Längden på den längsta sekvens som objektet kan styra.

merge

Kombinerar två sorterade sekvenser i en enda sorterad sekvens i linjär tid. Tar bort elementen från argumentlistan och infogar dem i den här forward_list. De två listorna ska sorteras efter samma jämförelsefunktionsobjekt innan anropet till merge. Den kombinerade listan sorteras efter det jämför funktionsobjektet.

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

Parameterar

right
Listan över vidarebefordran som ska sammanfogas från.

comp
Jämför funktionsobjektet som används för att sortera element.

Anmärkningar

forward_list::merge tar bort elementen forward_listrightfrån och infogar dem i den här forward_list. Båda sekvenserna måste sorteras efter samma predikat, som beskrivs nedan. Den kombinerade sekvensen sorteras också efter det jämför funktionsobjektet.

För iteratorerna Pi och Pj att utse element vid positioner i och j, lägger den första medlemsfunktionen ordningen !(*Pj < *Pi) när i < j. (Elementen sorteras i ascending ordning.) Den andra medlemsfunktionen tillämpar ordningen ! comp(*Pj, *Pi) när i < j.

Inga elementpar i den ursprungliga kontrollerade sekvensen ångras i den resulterande kontrollerade sekvensen. Om ett par element i den resulterande kontrollerade sekvensen jämförs lika med (!(*Pi < *Pj) && !(*Pj < *Pi)), visas ett element från den ursprungliga kontrollerade sekvensen före ett element från sekvensen som styrs av right.

Ett undantag inträffar endast om comp ett undantag genereras. I så fall lämnas den kontrollerade sekvensen i ospecificerad ordning och undantaget är återväxt.

operator=

Ersätter elementen i listan framåt med en kopia av en annan vidarebefordranlista.

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

Parameterar

right
Listan över vidarebefordran som kopieras till listan över vidarebefordran.

IList
En klammerparentessluten initialiserarlista som fungerar precis som en sekvens av element av typen Type.

Anmärkningar

Den första medlemsoperatorn ersätter den kontrollerade sekvensen med en kopia av sekvensen som styrs av right.

Den andra medlemsoperatorn ersätter den kontrollerade sekvensen från ett objekt av klassen initializer_list<Type>.

Den tredje medlemsoperatorn är samma som den första, men med en rvalue-referens .

pointer

En typ som ger en pekare till ett element i listan framåt.

typedef typename Allocator::pointer pointer;

pop_front

Tar bort elementet i början av en vidarebefordrad lista.

void pop_front();

Anmärkningar

Det första elementet i listan över vidarebefordran måste vara tomt.

Medlemsfunktionen utlöser aldrig ett undantag.

push_front

Lägger till ett element i början av en vidarebefordrningslista.

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

Parameterar

val
Elementet har lagts till i början av listan över vidarebefordran.

Anmärkningar

Om ett undantag utlöses lämnas containern oförändrad och undantaget ändras.

reference

En typ som ger en referens till ett element i listan över vidarebefordran.

typedef typename Allocator::reference reference;

remove

Raderar element i en framåtriktad lista som matchar ett angivet värde.

void remove(const Type& val);

Parameterar

val
Värdet som, om det innehas av ett element, resulterar i att elementet tas bort från listan.

Anmärkningar

Medlemsfunktionen tar bort alla element från den kontrollerade sekvensen, som anges av iteratorn P, för vilka *P == val.

Medlemsfunktionen utlöser aldrig ett undantag.

remove_if

Raderar element från en framåtriktad lista som ett angivet predikat är uppfyllt för.

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

Parameterar

pred
Det unary predikat som, om det uppfylls av ett element, resulterar i att elementet tas bort från listan.

Anmärkningar

Medlemsfunktionen tar bort alla element från den kontrollerade sekvensen, som anges av iteratorn P, för vilket pred(*P) är sant.

Ett undantag inträffar endast om pred ett undantag genereras. I så fall lämnas den kontrollerade sekvensen i ett ospecificerat tillstånd och undantaget är återväxt.

resize

Anger en ny storlek för en vidarebefordrningslista.

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

Parameterar

_Newsize
Antalet element i listan över ändrade vidarebefordran.

val
Värdet som ska användas för utfyllnad.

Anmärkningar

Medlemsfunktionerna säkerställer båda att antalet element i listan hädanefter är _Newsize. Om den måste göra den kontrollerade sekvensen längre lägger den första medlemsfunktionen till element med värdet Type(), medan den andra medlemsfunktionen lägger till element med värdet val. För att göra den kontrollerade sekvensen kortare anropar erase_after(begin() + _Newsize - 1, end())båda medlemsfunktionerna effektivt .

reverse

Ändrar ordningen i vilken elementen förekommer i en framåtriktad lista.

void reverse();

size_type

En typ som representerar det osignerade avståndet mellan två element.

typedef typename Allocator::size_type size_type;

Anmärkningar

Den osignerade heltalstypen beskriver ett objekt som kan representera längden på valfri kontrollerad sekvens.

sort

Ordnar elementen i stigande ordning eller med en ordning som anges av ett predikat.

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

Parameterar

pred
Beställningspredikatet.

Anmärkningar

Båda medlemsfunktionerna beställer elementen i den kontrollerade sekvensen efter ett predikat, som beskrivs nedan.

För iteratorerna Pi och Pj att utse element vid positioner i och j, lägger den första medlemsfunktionen ordningen !(*Pj < *Pi) när i < j. (Elementen sorteras i ascending ordning.) Medlemsmallsfunktionen tillämpar ordningen ! pred(*Pj, *Pi) när i < j. Inga ordnade par med element i den ursprungliga kontrollerade sekvensen ångras i den resulterande kontrollerade sekvensen. (Sorteringen är stabil.)

Ett undantag inträffar endast om pred ett undantag genereras. I så fall lämnas den kontrollerade sekvensen i ospecificerad ordning och undantaget är återväxt.

splice_after

Tar bort element från en källa forward_list och infogar dem i ett mål 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);

Parameterar

Where
Positionen i målet forward_list som ska infogas.

Source
forward_list Källan som ska infogas i målet forward_list.

Iter
Elementet som ska infogas från källan forward_list.

First
Det första elementet i intervallet som ska infogas från källan forward_list.

Last
Den första positionen utanför intervallet som ska infogas från källan forward_list.

Anmärkningar

Det första paret med medlemsfunktioner infogar sekvensen som styrs av Source strax efter elementet i den kontrollerade sekvensen som pekar på av Where. Den tar också bort alla element från Source. (&Source får inte vara lika med this.)

Det andra paret med medlemsfunktioner tar bort elementet strax efter Iter i sekvensen som styrs av Source och infogar det strax efter elementet i den kontrollerade sekvensen som pekar på av Where. (Om Where == Iter || Where == ++Itersker ingen ändring.)

Det tredje paret med medlemsfunktioner (ranged splice) infogar det underområde som anges av (First, Last) från sekvensen som styrs av Source strax efter att elementet i den kontrollerade sekvensen som pekas på av Where. Den tar också bort den ursprungliga underordningen från sekvensen som styrs av Source. (Om &Source == thisfår intervallet (First, Last) inte innehålla elementet som pekas på av Where.)

Om den intervallfördelade splicen infogar N element och &Source != this, ökas iterator ett klassobjekt N gånger.

Inga iteratorer, pekare eller referenser som anger skarvade element blir ogiltiga.

Exempel

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

Utbyter elementen i två framåtriktade listor.

void swap(forward_list& right);

Parameterar

right
Den vidarebefordrande listan som tillhandahåller de element som ska bytas ut.

Anmärkningar

Medlemsfunktionen växlar de kontrollerade sekvenserna mellan *this och right. Om get_allocator() == right.get_allocator(), det gör det i konstant tid, genererar det inga undantag och ogiltigförklarar inga referenser, pekare eller iteratorer som anger element i de två kontrollerade sekvenserna. Annars utför den elementtilldelningar och konstruktoranrop som är proportionella mot antalet element i de två kontrollerade sekvenserna.

unique

Eliminerar alla utom det första elementet från varje på varandra följande grupp med lika många element.

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

Parameterar

comp
Det binära predikatet som används för att jämföra efterföljande element.

Anmärkningar

Behåller det första av varje unikt element och tar bort resten. Elementen måste sorteras så att element med samma värde ligger intill varandra i listan.

Den första medlemsfunktionen tar bort varje element som jämförs med föregående element från den kontrollerade sekvensen. För iteratorerna Pi och Pj designelementen på positioner i och jtar den andra medlemsfunktionen bort varje element för vilket i + 1 == j && comp(*Pi, *Pj).

För en kontrollerad längdsekvens N (> 0) utvärderas comp(*Pi, *Pj) predikatet N - 1 gånger.

Ett undantag inträffar endast om comp ett undantag genereras. I så fall lämnas den kontrollerade sekvensen i ett ospecificerat tillstånd och undantaget är återväxt.

value_type

En typ som representerar den typ av element som lagras i en vidarebefordranlista.

typedef typename Allocator::value_type value_type;

Anmärkningar

Typen är en synonym för mallparametern Type.