Sådan bruges C ++ Vector

How Use C Vector



Introduktion

En matrix er en serie af samme objekttyper i på hinanden følgende hukommelsessteder. En matrix kan ikke øge malmets længde. En vektor er som en matrix, men dens længde kan øges eller reduceres. En vektor har derfor mange flere operationer end en matrix.

C ++ har mange biblioteker, som alle udgør C ++ standardbiblioteket. Et af disse biblioteker er containerbiblioteket. En container er en samling af objekter, og visse operationer kan udføres på samlingen. C ++ - containere kan grupperes i to sæt: sekvensbeholdere og associative containere. Sekvensbeholdere er vektor, array (ikke det samme array diskuteret tidligere), deque, forward_list og liste. Disse er forskellige samlinger (array-lignende datastrukturer), og hver tilbyder forskellige afvejninger.







Enhver programmør bør vide, hvordan man beslutter, om man skal bruge en vektor, en matrix, en deque, en forward_list eller en liste. Når en programmør har brug for en struktur, der kræver flere operationer end dem, der er forbundet med et almindeligt array, bør det almindelige array ikke bruges.



Hvis opgaven involverer hyppige indsættelser og sletninger i midten af ​​sekvensen, skal der bruges en liste eller fremadliste. Hvis opgaven involverer hyppige indsættelser og sletninger i begyndelsen eller slutningen af ​​en sekvens, skal der bruges en deque. En vektor bør bruges, når denne form for operationer ikke er påkrævet.



Denne artikel viser dig, hvordan du bruger C ++ - vektoren. Du skal bruge lidt viden om C ++ - pointers, referencer og arrays for at forstå denne artikel.





Klasse og genstande

En klasse er et sæt variabler og funktioner, der arbejder sammen, hvor variablerne ikke har værdier tildelt. Når værdier tildeles variablerne, bliver en klasse til et objekt. Forskellige værdier givet til den samme klasse resulterer i forskellige objekter; det vil sige, at forskellige objekter kan være af samme klasse, men har forskellige værdier. Oprettelse af et objekt fra en klasse er også kendt som instantiating objektet.

Udtrykket vektor beskriver en klasse. Et objekt, der er oprettet ud fra en vektor, har et navn, der vælges af programmøren.



En funktion, der tilhører en klasse, er nødvendig for at instantiere et objekt fra klassen. I C ++ har denne funktion det samme navn som navnet på klassen. Forskellige objekter oprettet (instantieret) fra klassen har forskellige navne givet til hver af dem af programmereren.

At skabe et objekt fra en klasse betyder at konstruere objektet; det betyder også instantiation af objektet.

Vektorklassen

Vektorklassen er allerede defineret og findes i biblioteket. For at bruge vektorklassen skal en programmør inkludere vektoroverskriften i filen med følgende forbehandlingsdirektiv:

#omfatte

Når overskriften er inkluderet, bliver alle vektorfunktionerne (datamedlemmer og medlemsfunktioner) tilgængelige. For at bruge tælleobjektet til at sende data til terminalen (konsollen) skal objektoverskriften også være inkluderet. For at skrive et program med vektoren som minimum skal følgende overskrifter være inkluderet:

#omfatte
#omfatte

Instantiering af en vektor

intfoo[10];

Ovenfor er deklarationen af ​​en matrix med navnet foo og antallet af elementer 10. Dette er en matrix af heltal. Deklarationen af ​​en vektor er den samme. For en vektor er antallet af elementer valgfrit, da vektorlængden kan stige eller falde.

På dette tidspunkt i programmet er vektorklassen allerede blevet defineret i biblioteket, og overskriften er inkluderet. Vektoren kan instantieres som følger:

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

Her er vektoren af ​​den specielle konstruktorfunktion. Den type data, vektoren vil indeholde, er int i vinkelparenteser. Udtrykket vtr er det navn, programmereren har valgt for vektoren. Endelig er 8 i parentes det foreløbige antal heltal, vektoren vil have.

Udtrykket std står for standard navnerum. Dette udtryk skal efterfølges af et dobbelt kolon i denne sammenhæng. Enhver kan skrive deres eget vektorklassebibliotek og bruge det. C ++ har imidlertid allerede et standardbibliotek med standardnavne, herunder vektor. For at bruge et standardnavn skal standardnavnet gå forud for std ::. For at undgå at skrive std :: hver gang i programmet for et standardnavn, kan programfilen starte som følger:

#omfatte
#omfatte
ved hjælp af navneområde std;

Overbelastning af en funktion

Når to eller flere forskellige funktionssignaturer har samme navn, siges det navn at være overbelastet. Når en funktion kaldes, bestemmer antallet og typen af ​​argumenter, hvilken funktion der udføres.

Konstruktion af en vektor

Konstruktion af en vektor betyder instantiation (oprettelse) af et vektorobjekt. Konstruktorfunktionen er overbelastet som følger:

vektor navn

Dette skaber en vektor med længde nul og type T. Følgende sætning opretter en vektor med nul længde af typen float med navnet vtr:

vektor<flyde>vtr;

vektor navn (n)

Dette skaber en vektor med n elementer af type T. En sætning for denne vektor med fire flydeelementer er som følger:

vektor<flyde>vtr(4);

vektor navn (n, t)

Dette skaber en vektor af n elementer initialiseret til værdien t. Følgende sætning skaber en vektor med 5 elementer, hvor hvert element har værdien 3,4:

vektor<flyde>vtr(5, 3.4);

Konstruerer med initialisering

En vektor kan konstrueres (oprettes) og initialiseres på samme tid på en af ​​følgende to måder:

vektor<flyde>vtr= {1.1, 2.2, 3.3, 4.4};

Eller

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};

Bemærk, at der ikke er parenteser lige efter objektnavnet. Parenteser, der bruges lige efter objektnavnet, skal have initialiseringslisten som følger:

vektor<flyde>vtr({1.1, 2.2, 3.3, 4.4});

En vektor kan konstrueres og initialiseres senere med initialiseringslisten. I dette tilfælde vil parenteserne ikke blive brugt:

vektor<flyde>vtr;
vtr= {1.1, 2.2, 3.3, 4.4};

vektor V2 (V1)

Dette er en kopikonstruktør. Det skaber en vektor V2 som en kopi af vektoren V1. Følgende kode illustrerer dette:

vektor<flyde>vtr1(5, 3.4);
vektor<flyde>vtr2(vtr1);

Tildeling af en vektor under konstruktion

Under konstruktionen kan der oprettes en tom vektor, mens en anden tildeles den som følger:

vektor<flyde>vtr1{1.1, 2.2, 3.3, 4.4};
vektor<flyde>vtr2=vtr1;

Den anden erklæring svarer til:

vektor<flyde>vtr2= {1.1, 2.2, 3.3, 4.4};

const Vector

En const -vektor er en vektor, hvis elementer ikke kan ændres. Værdierne i denne vektor er skrivebeskyttet. Når den er oprettet, vises vektoren som følger:

konstvektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};

I denne vektortype kan intet element tilføjes eller fjernes. Desuden kan ingen værdi ændres.

Konstruerer med Iterator

En skabelon giver en generisk repræsentation for en datatype. En iterator giver en generisk repræsentation af scanning gennem værdierne i en beholder. Syntaksen til at oprette en vektor med en iterator er som følger:

skabelon<klasse InputIterator>
vektor(InputIterator først,InputIterator sidste,konstAllokator& =Allokator());

Dette konstruerer en vektor for området [først, sidste) ved hjælp af den angivne allokator, som vil blive diskuteret senere i denne artikel.

Ødelægge en vektor

For at ødelægge en vektor skal du blot lade den gå ud af rækkevidde, og ødelæggelse håndteres automatisk.

Vektorkapacitet

størrelse_type kapacitet () const noexcept

Det samlede antal elementer, vektoren kan indeholde uden at kræve omlokering, returneres af funktionen kapacitetsmedlem. Et kodesegment for dette er som følger:

vektor<flyde>vtr(4);
intpå en=vtr.kapacitet();
koste<<på en<< ' n';

Outputtet er 4.

reserve (n)

Hukommelsesplads er ikke altid frit tilgængelig. Ekstra plads kan reserveres på forhånd. Overvej følgende kodesegment:

vektor<flyde>vtr(4);
vtr.reservere(6);
koste<<vtr.kapacitet() << ' n';

Outputtet er 6. Så den ekstra reserverede plads er 6 - 4 = 2 elementer. Funktionen returnerer ugyldig.

størrelse () const noexcept

Dette returnerer antallet af elementer i vektoren. Følgende kode illustrerer denne funktion:

vektor<flyde>vtr(4);
flydes=vtr.størrelse();
koste<<s<< ' n';

Outputtet er 4.

shrink_to_fit ()

Efter at have givet ekstra kapacitet til en vektor med reserve () -funktionen, kan vektoren sænkes til at passe til dens oprindelige størrelse. Følgende kode illustrerer dette:

vektor<flyde>vtr(4);
vtr.reservere(6);
vtr.shrink_to_fit();
ints=vtr.størrelse();
koste<<s<< ' n';

Outputtet er 4 og ikke 6. Funktionen returnerer ugyldig.

ændre størrelse (sz), ændre størrelse (sz, c)

Dette ændrer størrelsen på vektoren. Hvis den nye størrelse er mindre end den gamle, slettes elementerne mod slutningen. Hvis den nye størrelse er længere, tilføjes en vis standardværdi mod slutningen. For at få en bestemt værditilvækst skal du bruge funktionen resize () med to argumenter. Følgende kodesegment illustrerer brugen af ​​disse to funktioner:

vektor<flyde>vtr1{1.1, 2.2, 3.3, 4.4};
vtr1.ændre størrelsen(2);
koste<< 'Ny størrelse på vtr1:' <<vtr1.størrelse() << ' n';
vektor<flyde>vtr2{1.1, 2.2};
vtr2.ændre størrelsen(4, 8.8);
koste<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' n';

Outputtet er følgende:

Ny størrelse på vtr1: 2
vtr2: 1,1 2,2 8,8 8,8

Funktionerne returnerer ugyldige.

tom () const noexcept

Denne funktion returnerer 1 for sand, hvis der ikke er nogen elementer i vektoren og 0 for falsk, hvis vektoren er tom. Hvis en vektor har 4 placeringer for en bestemt datatype, f.eks. Float, uden nogen float -værdi, så er denne vektor ikke tom. Følgende kode illustrerer dette:

vektor<flyde>vtr;
koste<<vtr.tom() << ' n';
vektor<flyde>vt(4);
koste<<så dettom() << ' n';

vektor<flyde>v(4,3.5);
koste<<v.tom() << ' n';

Outputtet er følgende:

1
0
0

Adgang til vektorelement

En vektor kan være sub-scriptet (indekseret) som et array. Indekstælling begynder fra nul.

vektornavn [i]

Operationsvektornavnet [i] returnerer en reference til elementet ved ithindeks for vektoren. Følgende kodeudgange 3.3 for ovenstående vektor:

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
flydefl=vtr[2];
koste<<fl<< ' n';

vektornavn [i] konst

Operationen vektornavn [i] const udføres i stedet for vektornavn [i], når vektoren er en konstant vektor. Denne handling bruges i følgende kode:

konstvektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
flydefl=vtr[2];
koste<<fl<< ' n';

Udtrykket returnerer en konstant reference til ithelement i vektoren.

Tildeling af en værdi med Subscript

En værdi kan tildeles en ikke-konstant vektor som følger:

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vtr[2] = 8.8;
koste<<vtr[2] << ' n';

Outputtet er 8,8.

vectorName.at (i)

vectorName.at (i) er ligesom vectorName [i], men vectorName.at (i) er mere pålidelig. Følgende kode viser, hvordan denne vektor skal bruges:

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
flydefl=vtr.(2);
koste<<fl<< ' n';
()er et vektormedlemfungere.

vectorName.at (i) konst

vectorName.at (i) const er ligesom vectorName [i] const, men vectorName.at (i) const er mere pålidelig. vectorName.at (i) const udføres i stedet for vectorName.at (i) når vektoren er en konstant vektor. Denne vektor bruges i følgende kode:

konstvektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
flydefl=vtr.(2);
koste<<fl<< ' n';
() konster et vektormedlemfungere.

Tildeling af en værdi med funktionen at ()

En værdi kan tildeles en ikke-konstant vektor med funktionen at () som følger:

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vtr.(2) = 8.8;
koste<<vtr[2] << ' n';

Outputtet er 8,8.

Problem med sub-scripting

Problemet med sub-scripting (indeksering) er, at hvis indekset er uden for rækkevidde, kan nul returneres, eller der kan udstedes en fejl ved løbetid.

foran()

Dette returnerer en reference til det første element i vektoren uden at fjerne elementet. Outputtet af følgende kode er 1.1.

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
flydefl=vtr.foran();
koste<<fl<< ' n';

Elementet fjernes ikke fra vektoren.

foran () konst

Når vektorkonstruktionen går forud for const, udføres udtrykket front () const i stedet for front (). Dette bruges i følgende kode:

konstvektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
flydefl=vtr.foran();
koste<<fl<< ' n';

En konstant reference returneres. Elementet fjernes ikke fra vektoren.

tilbage()

Dette returnerer en reference til det sidste element i vektoren uden at fjerne elementet. Outputtet af følgende kode er 4.4.

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
flydefl=vtr.tilbage();
koste<<fl<< ' n';

tilbage () konst

Når vektorkonstruktionen går forud for const, eksekveres udtrykket back () const i stedet for back (). Dette bruges i følgende kode:

konstvektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
flydefl=vtr.tilbage();
koste<<fl<< ' n';

En konstant reference returneres. Elementet fjernes ikke fra vektoren.

Vektordataadgang

data () noexcept; data () const noexcept;

Begge disse returnerer en markør, så [data (), data () + størrelse ()) er et gyldigt område.

Dette vil blive dækket mere detaljeret senere i artiklen.

Returnerende Iteratorer og vektoren

En iterator er som en markør, men har mere funktionalitet end en markør.

begynde () noexcept

Returnerer en iterator, der peger på det første element i vektoren, som i følgende kodesegment:

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vektor<flyde> ::iteratoriter=vtr.begynde();
koste<< *iter<< ' n';

Outputtet er 1.1. Bemærk, at den erklæring, der modtager iteratoren, er blevet erklæret. Iteratoren bliver referenceret i et returudtryk for at opnå værdien på samme måde som en markør erfereret.

begin () const noexcept;

Returnerer en iterator, der peger på det første element i vektoren. Når vektorkonstruktionen går forud for const, udføres udtrykket begin () const i stedet for begin (). Under denne betingelse kan det tilsvarende element i vektoren ikke ændres. Dette bruges i følgende kode:

konstvektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vektor<flyde> ::const_iteratoriter=vtr.begynde();
koste<< *iter<< ' n';

Outputtet er 1.1. Bemærk, at const_iterator er blevet brugt denne gang i stedet for bare iterator til at modtage den returnerede iterator.

ende () noget undtagen

Returnerer en iterator, der peger umiddelbart ud over vektorens sidste element. Overvej følgende kodesegment:

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vektor<flyde> ::iteratoriter=vtr.ende();
koste<< *iter<< ' n';

Outputtet er 0, hvilket er meningsløst, da der ikke er noget konkret element ud over det sidste element.

ende () const noexcept

Returnerer en iterator, der peger umiddelbart ud over vektorens sidste element. Når vektorkonstruktionen går forud for const, eksekveres udtrykket end () const i stedet for end (). Overvej følgende kodesegment:

konstvektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vektor<flyde> ::const_iteratoriter=vtr.ende();
koste<< *iter<< ' n';

Outputtet er 0. Bemærk, at const_iterator er blevet brugt denne gang i stedet for bare iterator til at modtage den returnerede iterator.

Omvendt Iteration

Det er muligt at have en iterator, der gentager sig fra slutningen til lige før det første element.

rbegin () noget undtagen

Returnerer en iterator, der peger på det sidste element i vektoren, som i følgende kodesegment:

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vektor<flyde> ::reverse_iteratorrIter=vtr.begyndte igen();
koste<< *rIter<< ' n';

Outputtet er 4,4.

Bemærk, at erklæringen, der modtager den omvendte iterator, er blevet erklæret. Iteratoren bliver referenceret i et returudtryk for at opnå værdien på samme måde som en markør erfereret.

rbegin () const noexcept;

Returnerer en iterator, der peger på det sidste element i vektoren. Når vektorkonstruktionen går forud for const, udføres udtrykket rbegin () const i stedet for rbegin (). Under denne betingelse kan det tilsvarende element i vektoren ikke ændres. Denne funktion bruges i følgende kode:

konstvektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vektor<flyde> ::const_reverse_iteratorrIter=vtr.begyndte igen();
koste<< *rIter<< ' n';

Outputtet er 4,4.

Bemærk, at const_reverse_iterator denne gang er blevet brugt i stedet for kun reverse_iterator til at modtage den returnerede iterator.

render () noget undtagen

Returnerer en iterator, der peger lige før vektorens første element. Overvej følgende kodesegment:

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vektor<flyde> ::reverse_iteratorrIter=vtr.gør();
koste<< *rIter<< ' n';

Outputtet er 0, hvilket er meningsløst, da der ikke er noget konkret element lige før det første element.

render () const noexcept

Returnerer en iterator, der peger lige før vektorens første element. Når vektorkonstruktionen går forud for const, eksekveres udtrykket rend () const i stedet for rend (). Overvej følgende kodesegment:

konstvektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vektor<flyde> ::const_reverse_iteratorrIter=vtr.gør();
koste<< *rIter<< ' n';

Outputtet er 0.

Bemærk, at const_reverse_iterator denne gang er blevet brugt i stedet for kun reverse_iterator til at modtage den returnerede iterator.

Vector modifikatorer

En modifikator, der ændrer vektoren, kan tage eller returnere en iterator.

a. model (p, args)

Indsætter et objekt af type T konstrueret med std :: forward (args) ... før s.

For detaljer - se senere

insert (iteratorPosition, værdi)

Indsætter en kopi af værdien ved vektorens iteratorposition. Returnerer iteratoren (positionen) i vektoren, hvor kopien er placeret. Følgende kode viser, hvor værdien er placeret:

vektor<int>vtr{10, tyve, 30, 40};
vektor<int> ::iteratoriter=vtr.begynde();
++iter;
++iter;
vtr.indsæt(iter, 25);
koste<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3] << ' n';

Outputtet er: 20 25 30.

Bemærk, at iteratoren blev avanceret (inkrementeret) ligesom en markør.

En initialiseringsliste kan også indsættes, som følgende kode illustrerer:

vektor<int>vtr{10, tyve, 30, 40};
vektor<int> ::iteratoriter=vtr.begynde();
++iter;
++iter;
vtr.indsæt(iter, {25, 28});

koste<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3]<< '' <<vtr[4] << ' n';

Outputtet er: 20 25 28 30.

slet (position)

Fjerner et element på den position, som iteratoren peger på, og returnerer derefter iteratorpositionen. Følgende kode illustrerer dette:

vektor<int>vtr{10, tyve, 30, 40};
vektor<int> ::iteratoriter=vtr.begynde();
++iter;
++iter;
vtr.slette(iter);
koste<<vtr[0] << '' <<vtr[1] << '
'
<<vtr[2]<< ' n';

Outputtet er: 10 20 40

push_back (t), push_back (rv)

Bruges til at tilføje et enkelt element i slutningen af ​​vektoren. Brug push_back (t) som følger:

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vtr.skub tilbage(5.5);
flydefl=vtr[4];
koste<<fl<< ' n';

Outputtet er 5,5.

skub tilbage(rv): -se senere.

pop_back ()

Fjerner det sidste element uden at returnere det. Størrelsen på vektoren reduceres med 1. Følgende kode illustrerer dette:

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vtr.pop_back();
flydes=vtr.størrelse();
koste<<s<< ' n';

Outputtet er 3.

a. bytte (b)

To vektorer kan byttes, som illustreret i følgende kodesegment:

vektor<flyde>vtr1{1.1, 2.2, 3.3, 4.4};
vektor<flyde>vtr2{10, tyve};
vtr1.bytte rundt(vtr2);
koste<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'
<<vtr1[2] <<''<<vtr1[3] << ' n';

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

Outputtet er:

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

Bemærk, at længden af ​​en vektor øges, hvis det er nødvendigt. Værdier, der ikke havde udskiftninger, erstattes også af en standardværdi.

klar()

Fjerner alle elementer fra vektoren, som følgende kodesegment illustrerer:

vektor<flyde>vtr{1.1, 2.2, 3.3, 4.4};
vtr.klar();
koste<<vtr.størrelse() << ' n';

Outputtet er 0.

Lighed og relationelle operatører for vektorer

Operatøren ==

Returnerer 1 for true, hvis de to vektorer har samme størrelse, og de tilsvarende elementer er ens; ellers returnerer den 0 for falsk. For eksempel:

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

Outputtet er 0.

! = Operatøren

Returnerer 1 for true, hvis de to vektorer ikke har samme størrelse og/eller de tilsvarende elementer ikke er ens; ellers returnerer den 0 for falsk. For eksempel:

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

Outputtet er 1.

Det

Returnerer 1 for true, hvis den første vektor er den første vektors første delmængde, idet elementerne i de to lige store dele er de samme og i samme rækkefølge. Hvis begge vektorer er af samme størrelse og bevæger sig fra venstre mod højre, og der findes et element i den første vektor, der er mindre end det tilsvarende element i den anden vektor, så returneres 1 stadig. Ellers returneres 0 for false. For eksempel:

vektor<int>U{3, 1, 1};
vektor<int>V{3, 2, 1};
bool bl=U<V;
koste<<bl<< ' n';

Outputtet er 1.

> Operatøren

Vender tilbage! (U

Det<= Operator

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

Operatøren> =

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

Konklusion

En vektor er et eksempel på en sekvensbeholder. En vektor er en bedre form for det almindelige array og er instantieret fra en klasse. Vektorer har metoder, der er klassificeret under: konstruktion og tildeling, kapacitet, elementadgang, dataadgang, iteratorer, modifikatorer og numeriske overbelastede operatører.

Der er andre sekvensbeholdere, kaldet liste, forward_list og array. Hvis opgaven involverer hyppige indsættelser og sletninger i midten af ​​sekvensen, skal der bruges en liste eller fremadliste. Hvis opgaven involverer hyppige indsættelser og sletninger i begyndelsen eller slutningen af ​​sekvensen, skal der bruges en deque. Og derfor bør vektorer kun bruges, når disse former for operationer ikke er vigtige.