Jak používat C ++ Vector

How Use C Vector

Úvod

Pole je řada stejných typů objektů v po sobě jdoucích paměťových umístěních. Pole nemůže zvětšit nebo zmenšit délku. Vektor je jako pole, ale jeho délku lze zvětšit nebo zmenšit. Vektor má tedy mnohem více operací než pole.

C ++ má mnoho knihoven, z nichž všechny tvoří standardní knihovnu C ++. Jednou z těchto knihoven je kontejnerová knihovna. Kontejner je kolekce objektů a v kolekci lze provádět určité operace. C ++ kontejnery lze seskupit do dvou sad: sekvenční kontejnery a asociativní kontejnery. Sekvenční kontejnery jsou vektor, pole (nejedná se o stejné pole diskutované dříve), deque, forward_list a list. Jedná se o různé kolekce (datové struktury podobné maticím) a každá nabízí odlišné kompromisy.



Každý programátor by měl vědět, jak se rozhodnout, zda použije vektor, pole, deque, forward_list nebo seznam. Když programátor potřebuje strukturu, která vyžaduje více operací, než jaké jsou spojeny s běžným polem, běžné pole by nemělo být použito.



Pokud úkol zahrnuje časté vkládání a mazání uprostřed sekvence, měl by být použit seznam nebo seznam_předních_listů. Pokud úkol zahrnuje časté vkládání a odstraňování na začátku nebo na konci sekvence, měl by být použit deque. Pokud tyto druhy operací nejsou vyžadovány, měl by být použit vektor.



Tento článek ukazuje, jak používat vektor C ++. K pochopení tohoto článku budete potřebovat určité znalosti o ukazatelích C ++, referencích a polích.

Třída a objekty

Třída je sada proměnných a funkcí, které pracují společně, kde proměnné nemají přiřazené hodnoty. Když jsou proměnným přiřazeny hodnoty, třída se stane objektem. Různé hodnoty dané stejné třídě vedou k různým objektům; to znamená, že různé objekty mohou být stejné třídy, ale mají různé hodnoty. Vytvoření objektu ze třídy je také známé jako vytváření instance objektu.

Termín vektor popisuje třídu. Objekt vytvořený z vektoru má název zvolený programátorem.



Funkce, která patří do třídy, je potřebná k vytvoření instance objektu ze třídy. V C ++ má tato funkce stejný název jako název třídy. Různé objekty vytvořené (instance) ze třídy mají odlišná jména, která každému z nich programátor přidělí.

Vytvoření objektu ze třídy znamená konstrukci objektu; to také znamená instanci objektu.

Třída Vector

Vektorová třída již byla definována a je v knihovně. Chcete -li použít třídu vector, musí programátor zahrnout do souboru záhlaví vektoru s následující směrnicí předzpracování:

#zahrnout

Jakmile je záhlaví zahrnuto, zpřístupní se všechny vektorové funkce (datové členy a členské funkce). Chcete -li použít objekt count k výstupu dat do terminálu (konzoly), musí být zahrnuto také záhlaví objektu. Chcete -li napsat program s vektorem, musí obsahovat minimálně následující záhlaví:

#zahrnout
#zahrnout

Vytvoření instance vektoru

intfoo[10];

Nahoře je deklarace pole s názvem foo a počtem prvků 10. Toto je pole celých čísel. Deklarace vektoru je podobná. U vektoru je počet prvků volitelný, protože délka vektoru se může zvětšovat nebo zmenšovat.

V tomto bodě programu již byla v knihovně definována vektorová třída a bylo zahrnuto záhlaví. Vektor lze vytvořit instancí následujícím způsobem:

hodiny::vektor <int>vtr(8);

Zde je vektor speciální funkce konstruktoru. Typ dat, které bude vektor uchovávat, je int, v hranatých závorkách. Termín vtr je název zvolený programátorem pro vektor. Nakonec 8 v závorkách je předběžný počet celých čísel, která bude mít vektor.

Termín std znamená standardní obor názvů. Za tímto termínem musí v této souvislosti následovat dvojtečka. Kdokoli může napsat svou vlastní knihovnu vektorových tříd a používat ji. C ++ však již má standardní knihovnu se standardními názvy, včetně vektoru. Chcete -li použít standardní název, musí standardnímu názvu předcházet std ::. Aby se zabránilo zadávání std :: pokaždé v programu pro standardní název, soubor programu může začít následovně:

#zahrnout
#zahrnout
pomocí oboru názvů std;

Přetížení funkce

Pokud mají dva nebo více různých podpisů funkcí stejný název, je tento název údajně přetížen. Při volání jedné funkce určuje počet a typ argumentů, která funkce se provede.

Konstrukce vektoru

Sestavení vektoru znamená vytvoření instance (vytvoření) vektorového objektu. Funkce konstruktoru je přetížena následovně:

vektorový název

Tím se vytvoří vektor délky nula a typu T. Následující příkaz vytvoří vektor nulové délky typu float s názvem vtr:

vektor<plovák>vtr;

název vektoru (n)

Tím se vytvoří vektor s n prvky typu T. Příkaz pro tento vektor se čtyřmi prvky typu float je následující:

vektor<plovák>vtr(4);

název vektoru (n, t)

Tím se vytvoří vektor n prvků inicializovaných na hodnotu t. Následující příkaz vytvoří vektor 5 prvků, kde každý prvek má hodnotu 3,4:

vektor<plovák>vtr(5, 3.4);

Konstrukce s inicializací

Vektor lze zkonstruovat (vytvořit) a inicializovat současně jedním z následujících dvou způsobů:

vektor<plovák>vtr= {1.1, 2.2, 3.3, 4.4};

Nebo

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};

Všimněte si, že hned za názvem objektu nejsou žádné závorky. Závorky použité hned za názvem objektu by měly mít seznam inicializátorů, a to následovně:

vektor<plovák>vtr({1.1, 2.2, 3.3, 4.4});

Vektor lze sestavit a inicializovat později pomocí seznamu inicializátorů. V tomto případě se závorky nepoužijí:

vektor<plovák>vtr;
vtr= {1.1, 2.2, 3.3, 4.4};

vektor V2 (V1)

Toto je konstruktor kopií. Vytvoří vektor V2 jako kopii vektoru V1. Následující kód to ilustruje:

vektor<plovák>vtr1(5, 3.4);
vektor<plovák>vtr2(vtr1);

Přiřazení vektoru během stavby

Během výstavby lze vytvořit prázdný vektor, zatímco je mu přiřazen jiný, a to následovně:

vektor<plovák>vtr1{1.1, 2.2, 3.3, 4.4};
vektor<plovák>vtr2=vtr1;

Druhé prohlášení je ekvivalentní:

vektor<plovák>vtr2= {1.1, 2.2, 3.3, 4.4};

const Vektor

Vektor const je vektor, jehož prvky nelze změnit. Hodnoty v tomto vektoru jsou jen pro čtení. Po vytvoření se vektor zobrazí následovně:

konstvektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};

V tomto vektorovém typu nelze přidat ani odebrat žádný prvek. Navíc nelze změnit žádnou hodnotu.

Konstrukce s iterátorem

Šablona poskytuje obecnou reprezentaci pro datový typ. Iterátor poskytuje obecnou reprezentaci skenování hodnot kontejneru. Syntaxe k vytvoření vektoru s iterátorem je následující:

šablona<třída InputIterator>
vektor(InputIterator jako první,InputIterator poslední,konstPřidělovač& =Přidělovač());

Toto vytvoří vektor pro rozsah [první, poslední] pomocí zadaného alokátoru, o kterém bude pojednáno dále v tomto článku.

Ničení vektoru

Chcete -li zničit vektor, jednoduše jej nechejte mimo rozsah a zničení je zpracováno automaticky.

Vektorová kapacita

size_type capacity () const noexcept

Celkový počet prvků, které může vektor pojmout bez nutnosti přerozdělení, je vrácen funkcí člena kapacity. Segment kódu pro toto je následující:

vektor<plovák>vtr(4);
intna jednom=vtr.kapacita();
náklady<<na jednom<< ' n';

Výstup je 4.

rezerva (n)

Paměťový prostor není vždy volně dostupný. Prostor navíc lze rezervovat předem. Zvažte následující segment kódu:

vektor<plovák>vtr(4);
vtr.rezervovat(6);
náklady<<vtr.kapacita() << ' n';

Výstup je 6. Rezervovaný prostor navíc je 6 - 4 = 2 prvky. Funkce vrací neplatné.

size () const noexcept

Tím se vrátí počet prvků ve vektoru. Následující kód ilustruje tuto funkci:

vektor<plovák>vtr(4);
plováks=vtr.velikost();
náklady<<s<< ' n';

Výstup je 4.

shrink_to_fit ()

Po poskytnutí extra kapacity vektoru s funkcí Reserve () lze vektor zmenšit tak, aby odpovídal jeho původní velikosti. Následující kód to ilustruje:

vektor<plovák>vtr(4);
vtr.rezervovat(6);
vtr.shrink_to_fit();
ints=vtr.velikost();
náklady<<s<< ' n';

Výstup je 4 a ne 6. Funkce vrací neplatné.

resize (sz), resize (sz, c)

Tím se změní velikost vektoru. Pokud je nová velikost menší než stará velikost, prvky na konci budou vymazány. Pokud je nová velikost delší, přidá se ke konci nějaká výchozí hodnota. Chcete -li přidat konkrétní hodnotu, použijte funkci resize () se dvěma argumenty. Následující segment kódu ukazuje použití těchto dvou funkcí:

vektor<plovák>vtr1{1.1, 2.2, 3.3, 4.4};
vtr1.změnit velikost(2);
náklady<< 'Nová velikost vtr1:' <<vtr1.velikost() << ' n';
vektor<plovák>vtr2{1.1, 2.2};
vtr2.změnit velikost(4, 8.8);
náklady<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' n';

Výstup je následující:

Nová velikost vtr1: 2
vtr2: 1,1 2,2 8,8 8,8

Funkce se vrací neplatné.

empty () const noexcept

Tato funkce vrací 1 pro true, pokud ve vektoru nejsou žádné prvky, a 0 pro false, pokud je vektor prázdný. Pokud má vektor 4 místa pro určitý typ dat, například float, bez jakékoli hodnoty typu float, pak tento vektor není prázdný. Následující kód to ilustruje:

vektor<plovák>vtr;
náklady<<vtr.prázdný() << ' n';
vektor<plovák>vt(4);
náklady<<abyprázdný() << ' n';

vektor<plovák>proti(4,3.5);
náklady<<proti.prázdný() << ' n';

Výstup je následující:

1
0
0

Přístup k prvkům Vector

Vektor lze podskriptovat (indexovat) jako pole. Počítání indexů začíná od nuly.

vectorName [i]

Operace vectorName [i] vrací odkaz na prvek v ithindex vektoru. Následující výstup kódu 3.3 pro výše uvedený vektor:

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
plovákfl=vtr[2];
náklady<<fl<< ' n';

vectorName [i] konst

Operace vectorName [i] const se provede místo vectorName [i], když je vektor konstantní vektor. Tato operace se používá v následujícím kódu: This operation is used in the following code:

konstvektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
plovákfl=vtr[2];
náklady<<fl<< ' n';

Výraz vrací konstantní odkaz na ithprvek vektoru.

Přiřazení hodnoty pomocí indexu

Nekonstantnímu vektoru lze přiřadit hodnotu následujícím způsobem:

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vtr[2] = 8.8;
náklady<<vtr[2] << ' n';

Výstup je 8,8.

vectorName.at (i)

vectorName.at (i) je jako vectorName [i], ale vectorName.at (i) je spolehlivější. Následující kód ukazuje, jak by měl být tento vektor použit:

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
plovákfl=vtr.na(2);
náklady<<fl<< ' n';
na()je vektorový členfunkce.

vectorName.at (i) konst

vectorName.at (i) const je jako vectorName [i] const, ale vectorName.at (i) const je spolehlivější. vectorName.at (i) const se provede místo vectorName.at (i), když je vektor konstantní vektor. Tento vektor se používá v následujícím kódu:

konstvektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
plovákfl=vtr.na(2);
náklady<<fl<< ' n';
na() konstje vektorový členfunkce.

Přiřazení hodnoty pomocí funkce at ()

Nekonstantnímu vektoru lze pomocí funkce at () přiřadit hodnotu následovně:

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vtr.na(2) = 8.8;
náklady<<vtr[2] << ' n';

Výstup je 8,8.

Problém s podskriptováním

Problém subskriptování (indexování) je ten, že pokud je index mimo rozsah, může být vrácena nula nebo může být za běhu vydána chyba.

přední()

Tím se vrátí odkaz na první prvek vektoru bez odebrání prvku. Výstupem následujícího kódu je 1.1.

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
plovákfl=vtr.přední();
náklady<<fl<< ' n';

Prvek není z vektoru odstraněn.

front () konst

Když konstrukci vektoru předchází const, provede se výraz front () const místo front (). To se používá v následujícím kódu:

konstvektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
plovákfl=vtr.přední();
náklady<<fl<< ' n';

Je vrácena konstantní reference. Prvek není z vektoru odstraněn.

zadní()

Tím se vrátí odkaz na poslední prvek vektoru bez odebrání prvku. Výstupem následujícího kódu je 4.4.

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
plovákfl=vtr.zadní();
náklady<<fl<< ' n';

zpět () konst

Když konstrukci vektoru předchází const, provede se místo back () výraz back () const. To se používá v následujícím kódu:

konstvektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
plovákfl=vtr.zadní();
náklady<<fl<< ' n';

Je vrácena konstantní reference. Prvek není z vektoru odstraněn.

Vektorový přístup k datům

data () noexcept; data () const noexcept;

Každý z nich vrací ukazatel tak, že [data (), data () + size ()) je platný rozsah.

To bude podrobněji popsáno dále v článku.

Vracející se iterátory a vektor

Iterátor je jako ukazatel, ale má více funkcí než ukazatel.

begin () noexcept

Vrátí iterátor, který ukazuje na první prvek vektoru, jako v následujícím segmentu kódu:

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plovák> ::iterátoriter=vtr.začít();
náklady<< *iter<< ' n';

Výstup je 1,1. Všimněte si, že deklarace, která obdrží iterátor, byla deklarována. Iterátor je dereferencován v návratovém výrazu, aby získal hodnotu stejným způsobem, jako je dereferencován ukazatel.

begin () const noexcept;

Vrátí iterátor, který ukazuje na první prvek vektoru. Když konstrukci vektoru předchází const, provede se místo begin () výraz begin () const. Za této podmínky nelze odpovídající prvek ve vektoru upravit. To se používá v následujícím kódu:

konstvektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plovák> ::const_iteratoriter=vtr.začít();
náklady<< *iter<< ' n';

Výstup je 1,1. Všimněte si toho, že tentokrát byl přijat vrácený iterátor namísto pouze iterátoru const_iterator.

end () noexcept

Vrátí iterátor, který ukazuje bezprostředně za poslední prvek vektoru. Zvažte následující segment kódu:

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plovák> ::iterátoriter=vtr.konec();
náklady<< *iter<< ' n';

Výstup je 0, což je nesmyslné, protože za posledním prvkem není žádný konkrétní prvek.

end () const noexcept

Vrátí iterátor, který ukazuje bezprostředně za poslední prvek vektoru. Když konstrukci vektoru předchází const, provede se místo end () výraz end () const. Zvažte následující segment kódu:

konstvektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plovák> ::const_iteratoriter=vtr.konec();
náklady<< *iter<< ' n';

Výstup je 0. Všimněte si, že tentokrát byl pro příjem vráceného iterátoru použit const_iterator místo pouze iterátoru.

Reverzní iterace

Je možné mít iterátor, který iteruje od konce do těsně před prvním prvkem.

rbegin () noexcept

Vrátí iterátor, který ukazuje na poslední prvek vektoru, jako v následujícím segmentu kódu:

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plovák> ::reverzní_iterátorpřímější=vtr.rbegin();
náklady<< *přímější<< ' n';

Výstup je 4,4.

Všimněte si, že deklarace, která obdrží zpětný iterátor, byla deklarována. Iterátor je dereferencován v návratovém výrazu, aby získal hodnotu stejným způsobem, jako je dereferencován ukazatel.

rbegin () const noexcept;

Vrátí iterátor, který ukazuje na poslední prvek vektoru. Když konstrukci vektoru předchází const, místo rbegin () se provede výraz rbegin () const. Za této podmínky nelze odpovídající prvek ve vektoru upravit. Tato funkce se používá v následujícím kódu: This feature is used in the following code:

konstvektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plovák> ::const_reverse_iteratorpřímější=vtr.rbegin();
náklady<< *přímější<< ' n';

Výstup je 4,4.

Všimněte si, že tentokrát byl pro příjem vráceného iterátoru použit const_reverse_iterator, namísto pouze reverse_iterator.

render () noexcept

Vrátí iterátor, který ukazuje těsně před první prvek vektoru. Zvažte následující segment kódu:

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plovák> ::reverzní_iterátorpřímější=vtr.dělá();
náklady<< *přímější<< ' n';

Výstup je 0, což je nesmyslné, protože těsně před prvním prvkem není žádný konkrétní prvek.

render () const noexcept

Vrátí iterátor, který ukazuje těsně před první prvek vektoru. Když konstrukci vektoru předchází const, místo rend () se provede výraz rend () const. Zvažte následující segment kódu:

konstvektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plovák> ::const_reverse_iteratorpřímější=vtr.dělá();
náklady<< *přímější<< ' n';

Výstup je 0.

Všimněte si, že tentokrát byl pro příjem vráceného iterátoru použit const_reverse_iterator, namísto pouze reverse_iterator.

Modifikátory vektoru

Modifikátor, který upravuje vektor, může převzít nebo vrátit iterátor.

a. místo (p, args)

Vloží objekt typu T zkonstruovaný pomocí std :: forward (args) ... před p.

Podrobnosti - viz později

insert (iteratorPosition, hodnota)

Vloží kopii hodnoty na pozici iterátoru vektoru. Vrátí iterátor (pozici) ve vektoru, kde byla umístěna kopie. Následující kód ukazuje, kde byla hodnota umístěna:

vektor<int>vtr{10, dvacet, 30, 40};
vektor<int> ::iterátoriter=vtr.začít();
++iter;
++iter;
vtr.vložit(iter, 25);
náklady<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3] << ' n';

Výstup je: 20 25 30.

Všimněte si, že iterátor byl pokročilý (inkrementovaný) stejně jako ukazatel.

Lze také vložit seznam inicializátorů, jak ukazuje následující kód:

vektor<int>vtr{10, dvacet, 30, 40};
vektor<int> ::iterátoriter=vtr.začít();
++iter;
++iter;
vtr.vložit(iter, {25, 28});

náklady<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3]<< '' <<vtr[4] << ' n';

Výstup je: 20 25 28 30.

vymazat (pozice)

Odebere prvek v poloze, na kterou iterátor ukazuje, a poté vrátí pozici iterátoru. Následující kód to ilustruje:

vektor<int>vtr{10, dvacet, 30, 40};
vektor<int> ::iterátoriter=vtr.začít();
++iter;
++iter;
vtr.vymazat(iter);
náklady<<vtr[0] << '' <<vtr[1] << '
'
<<vtr[2]<< ' n';

Výstup je: 10 20 40

push_back (t), push_back (rv)

Slouží k přidání jednoho prvku na konec vektoru. Push_back (t) použijte následovně:

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vtr.zatlačit zpátky(5.5);
plovákfl=vtr[4];
náklady<<fl<< ' n';

Výstup je 5,5.

zatlačit zpátky(rv): -viz později.

pop_back ()

Odebere poslední prvek, aniž by jej vrátil. Velikost vektoru se zmenší o 1. Následující kód to ilustruje:

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vtr.pop_back();
plováks=vtr.velikost();
náklady<<s<< ' n';

Výstup je 3.

a.swap (b)

Dva vektory lze vyměnit, jak je znázorněno v následujícím segmentu kódu:

vektor<plovák>vtr1{1.1, 2.2, 3.3, 4.4};
vektor<plovák>vtr2{10, dvacet};
vtr1.vyměnit(vtr2);
náklady<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'
<<vtr1[2] <<''<<vtr1[3] << ' n';

náklady<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' n';

Výstupem je:

vtr1: 10 dvacet 0 0
vtr2: 1.1 2.2 3.3 4.4

V případě potřeby se délka vektoru prodlouží. Také hodnoty, které neměly náhrady, jsou nahrazeny nějakou výchozí hodnotou.

Průhledná()

Odebere všechny prvky z vektoru, jak ukazuje následující segment kódu:

vektor<plovák>vtr{1.1, 2.2, 3.3, 4.4};
vtr.Průhledná();
náklady<<vtr.velikost() << ' n';

Výstup je 0.

Operátory rovnosti a relace pro vektory

Operátor ==

Vrátí 1 pro true, pokud mají dva vektory stejnou velikost a odpovídající prvky jsou stejné; jinak vrátí 0 pro false. Například:

vektor<int>U{1, 2, 3};
vektor<int>PROTI{4, 5, 6};
bool bl=U==PROTI;
náklady<<bl<< ' n';

Výstup je 0.

Operátor! =

Vrací 1 pro true, pokud dva vektory nemají stejnou velikost a/nebo odpovídající prvky nejsou stejné; jinak vrátí 0 pro false. Například:

vektor<int>U{1, 2, 3};
vektor<int>PROTI{4, 5, 6};
bool bl=U! =PROTI;
náklady<<bl<< ' n';

Výstup je 1.

The

Vrátí 1 pro true, pokud je první vektor počáteční podmnožinou druhého vektoru, přičemž prvky dvou stejných částí jsou stejné a ve stejném pořadí. Pokud jsou oba vektory stejné velikosti a pohybují se zleva doprava a v prvním vektoru je nalezen prvek, který je menší než odpovídající prvek ve druhém vektoru, pak bude stále vrácen 1. Jinak se vrátí 0 pro false. Například:

vektor<int>U{3, 1, 1};
vektor<int>PROTI{3, 2, 1};
bool bl=U<PROTI;
náklady<<bl<< ' n';

Výstup je 1.

> Operátor

Vrací! (U

The<= Operator

Vrací U<= V, where U is the first vector and V is the second vector, according to the above definitions.

Operátor> =

Vrací! (U<= V), where U is the first vector and V is the second vector, according to the above definitions.

Závěr

Vektor je příkladem sekvenčního kontejneru. Vektor je lepší forma obyčejného pole a je vytvořen z třídy. Vektory mají metody, které jsou klasifikovány pod: konstrukce a přiřazení, kapacita, přístup k prvkům, přístup k datům, iterátory, modifikátory a numericky přetížené operátory.

Existují další kontejnery sekvencí, nazývané list, forward_list a array. Pokud úkol zahrnuje časté vkládání a mazání uprostřed sekvence, měl by být použit seznam nebo seznam_předních_listů. Pokud úkol zahrnuje časté vkládání a odstraňování na začátku nebo na konci sekvence, měl by být použit deque. Vektory by tedy měly být použity pouze tehdy, když tyto druhy operací nejsou důležité.