Slik bruker du C ++ Vector

How Use C Vector



Introduksjon

En matrise er en serie av samme objekttyper på påfølgende minnesteder. En matrise kan ikke øke eller redusere lengden på malm. En vektor er som en matrise, men lengden kan økes eller reduseres. En vektor har derfor mange flere operasjoner enn en matrise.

C ++ har mange biblioteker, som alle danner C ++ standardbibliotek. Et av disse bibliotekene er containerbiblioteket. En beholder er en samling objekter, og visse operasjoner kan utføres på samlingen. C ++ - beholdere kan grupperes i to sett: sekvensbeholdere og assosiative beholdere. Sekvensbeholdere er vektor, matrise (ikke samme matrise diskutert tidligere), deque, forward_list og liste. Dette er forskjellige samlinger (matriselignende datastrukturer), og hver tilbyr forskjellige avveininger.







Enhver programmerer bør vite hvordan han skal bestemme om han skal bruke en vektor, en matrise, en deque, en forward_list eller en liste. Når en programmerer trenger en struktur som krever flere operasjoner enn de som er knyttet til en vanlig matrise, bør den vanlige matrisen ikke brukes.



Hvis oppgaven innebærer hyppige innsetting og sletting i midten av sekvensen, bør en liste eller fremoverliste brukes. Hvis oppgaven innebærer hyppige innsetting og sletting i begynnelsen eller slutten av en sekvens, bør en deque brukes. En vektor bør brukes når slike operasjoner ikke er nødvendig.



Denne artikkelen viser deg hvordan du bruker C ++ - vektoren. Du trenger litt kunnskap om C ++ - pekere, referanser og matriser for å forstå denne artikkelen.





Klasse og objekter

En klasse er et sett med variabler og funksjoner som fungerer sammen, der variablene ikke har verdier tilordnet. Når verdier er tilordnet variablene, blir en klasse til et objekt. Ulike verdier gitt til samme klasse resulterer i forskjellige objekter; det vil si at forskjellige objekter kan være av samme klasse, men ha forskjellige verdier. Å lage et objekt fra en klasse er også kjent som instantiating objektet.

Begrepet vektor beskriver en klasse. Et objekt opprettet fra en vektor har et navn som er valgt av programmereren.



En funksjon som tilhører en klasse er nødvendig for å instantiere et objekt fra klassen. I C ++ har den funksjonen samme navn som navnet på klassen. Ulike objekter opprettet (instantiert) fra klassen har forskjellige navn gitt til hver av dem av programmereren.

Å lage et objekt fra en klasse betyr å konstruere objektet; det betyr også instantiating objektet.

Vektorklassen

Vektorklassen er allerede definert og er i biblioteket. For å bruke vektorklassen må en programmerer inkludere vektoroverskriften i filen med følgende forhåndsbehandlingsdirektiv:

#inkludere

Når overskriften er inkludert, blir alle vektorfunksjonene (datamedlemmer og medlemsfunksjoner) tilgjengelige. For å bruke telleobjektet til å sende data til terminalen (konsollen), må objektoverskriften også inkluderes. For å skrive et program med vektoren som minimum, må følgende overskrifter inkluderes:

#inkludere
#inkludere

Instantiating a Vector

intfoo[10];

Over er deklarasjonen av en matrise med navnet foo og antall elementer 10. Dette er en rekke heltall. Erklæringen av en vektor er lik. For en vektor er antall elementer valgfritt, siden vektorlengden kan øke eller redusere.

På dette tidspunktet i programmet har vektorklassen allerede blitt definert i biblioteket, og overskriften er inkludert. Vektoren kan instantieres som følger:

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

Her er vektoren av den spesielle konstruktørfunksjonen. Datatypen vektoren vil inneholde er int, i vinkelparenteser. Begrepet vtr er navnet valgt av programmereren for vektoren. Til slutt er 8, i parentes, det foreløpige antallet heltall som vektoren vil ha.

Begrepet std står for standard navnerom. Dette begrepet må følges av et dobbelt kolon, i denne sammenhengen. Hvem som helst kan skrive sitt eget vektorklassebibliotek og bruke det. Imidlertid har C ++ allerede et standardbibliotek med standardnavn, inkludert vektor. For å bruke et standardnavn må standardnavnet stå foran std ::. For å unngå å skrive std :: hver gang i programmet for et standardnavn, kan programfilen starte som følger:

#inkludere
#inkludere
ved hjelp av navneområde std;

Overbelastning av en funksjon

Når to eller flere forskjellige funksjonssignaturer har samme navn, sies det at navnet er overbelastet. Når en funksjon kalles, bestemmer antallet og typen argumenter hvilken funksjon som utføres.

Konstruere en vektor

Å konstruere en vektor betyr å instantiere (lage) et vektorobjekt. Konstruktorfunksjonen er overbelastet som følger:

vektornavn

Dette oppretter en vektor med lengde null og type T. Følgende setning lager en vektor med null lengde av typen float med navnet vtr:

vektor<flyte>vtr;

vektornavn (n)

Dette skaper en vektor med n elementer av type T. En setning for denne vektoren med fire flyteelementer er som følger:

vektor<flyte>vtr(4);

vektornavn (n, t)

Dette skaper en vektor av n elementer initialisert til verdien t. Følgende setning lager en vektor med 5 elementer, der hvert element har verdien 3,4:

vektor<flyte>vtr(5, 3.4);

Konstruere med initialisering

En vektor kan konstrueres (opprettes) og initialiseres samtidig på en av følgende to måter:

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

Eller

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

Vær oppmerksom på at det ikke er parenteser rett etter objektnavnet. Parenteser som brukes like etter objektnavnet, bør ha initialiseringslisten som følger:

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

En vektor kan konstrueres og initialiseres senere med initialiseringslisten. I dette tilfellet vil ikke parentesene brukes:

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

vektor V2 (V1)

Dette er en kopikonstruktør. Den oppretter en vektor V2 som en kopi av vektoren V1. Følgende kode illustrerer dette:

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

Tildele en vektor under konstruksjonen

Under konstruksjonen kan en tom vektor opprettes mens en annen er tilordnet den, som følger:

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

Den andre uttalelsen tilsvarer:

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

const Vector

En const -vektor er en vektor hvis elementer ikke kan endres. Verdiene i denne vektoren er skrivebeskyttet. Når den er opprettet, vises vektoren som følger:

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

I denne vektortypen kan ingen elementer legges til eller fjernes. Dessuten kan ingen verdi endres.

Konstruerer med Iterator

En mal gir en generisk representasjon for en datatype. En iterator gir en generisk fremstilling av skanning gjennom verdiene til en beholder. Syntaksen for å lage en vektor med en iterator er som følger:

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

Dette konstruerer en vektor for området [først, siste) ved hjelp av den angitte tildeleren, som vil bli diskutert senere i denne artikkelen.

Ødelegge en vektor

For å ødelegge en vektor, bare la den gå ut av omfanget og ødeleggelse håndteres automatisk.

Vektorkapasitet

size_type kapasitet () const noexcept

Det totale antallet elementer vektoren kan inneholde uten å kreve omdisponering returneres av kapasitetsmedlemfunksjonen. Et kodesegment for dette er som følger:

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

Utgangen er 4.

reserve (n)

Minneplass er ikke alltid fritt tilgjengelig. Ekstra plass kan reserveres på forhånd. Vurder følgende kodesegment:

vektor<flyte>vtr(4);
vtr.reservere(6);
koste<<vtr.kapasitet() << ' n';

Utgangen er 6. Så den ekstra reserverte plassen er 6 - 4 = 2 elementer. Funksjonen returnerer ugyldig.

size () const noexcept

Dette returnerer antall elementer i vektoren. Følgende kode illustrerer denne funksjonen:

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

Utgangen er 4.

krymp for å passe()

Etter å ha gitt ekstra kapasitet til en vektor med reserve () -funksjonen, kan vektoren dimensjoneres for å passe til sin opprinnelige størrelse. Følgende kode illustrerer dette:

vektor<flyte>vtr(4);
vtr.reservere(6);
vtr.krymp for å passe();
ints=vtr.størrelse();
koste<<s<< ' n';

Utgangen er 4 og ikke 6. Funksjonen returnerer ugyldig.

endre størrelse (sz), endre størrelse (sz, c)

Dette endrer størrelsen på vektoren. Hvis den nye størrelsen er mindre enn den gamle, blir elementene mot slutten slettet. Hvis den nye størrelsen er lengre, blir noen standardverdi lagt til mot slutten. For å få en bestemt verdiøkning, bruk funksjonen resize () med to argumenter. Følgende kodesegment illustrerer bruken av disse to funksjonene:

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

Utgangen er følgende:

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

Funksjonene returnerer ugyldige.

tom () const noexcept

Denne funksjonen returnerer 1 for true hvis det ikke er noen elementer i vektoren og 0 for usant hvis vektoren er tom. Hvis en vektor har 4 steder for en bestemt type data, for eksempel float, uten noen flyteverdi, er ikke denne vektoren tom. Følgende kode illustrerer dette:

vektor<flyte>vtr;
koste<<vtr.tømme() << ' n';
vektor<flyte>vt(4);
koste<<så dettømme() << ' n';

vektor<flyte>v(4,3.5);
koste<<v.tømme() << ' n';

Utgangen er følgende:

1
0
0

Tilgang til vektorelement

En vektor kan være sub-scriptet (indeksert) som en matrise. Indekstelling begynner fra null.

vektornavn [i]

Operasjonsvektorenavn [i] returnerer en referanse til elementet ved ithindeks for vektoren. Følgende kodeutganger 3.3 for vektoren ovenfor:

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

vektornavn [i] konst

Operasjonen vektornavn [i] const kjøres i stedet for vektornavn [i] når vektoren er en konstant vektor. Denne operasjonen brukes i følgende kode:

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

Uttrykket returnerer en konstant referanse til ithelement i vektoren.

Tilordne en verdi med Subscript

En verdi kan tilordnes en ikke-konstant vektor på følgende måte:

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

Utgangen er 8,8.

vectorName.at (i)

vectorName.at (i) er som vectorName [i], men vectorName.at (i) er mer pålitelig. Følgende kode viser hvordan denne vektoren skal brukes:

vektor<flyte>vtr{1.1, 2.2, 3.3, 4.4};
flytefl=vtr.(2);
koste<<fl<< ' n';
()er et vektormedlemfunksjon.

vectorName.at (i) konst

vectorName.at (i) const er som vectorName [i] const, men vectorName.at (i) const er mer pålitelig. vectorName.at (i) const kjøres i stedet for vectorName.at (i) når vektoren er en konstant vektor. Denne vektoren brukes i følgende kode:

konstvektor<flyte>vtr{1.1, 2.2, 3.3, 4.4};
flytefl=vtr.(2);
koste<<fl<< ' n';
() konster et vektormedlemfunksjon.

Tilordne en verdi med funksjonen at ()

En verdi kan tilordnes en ikke-konstant vektor med funksjonen at (), som følger:

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

Utgangen er 8,8.

Problem med sub-scripting

Problemet med sub-scripting (indeksering) er at hvis indeksen er utenfor området, kan null returneres eller det kan utstedes en feil ved kjøretid.

front()

Dette returnerer en referanse til det første elementet i vektoren uten å fjerne elementet. Utdataene fra følgende kode er 1.1.

vektor<flyte>vtr{1.1, 2.2, 3.3, 4.4};
flytefl=vtr.front();
koste<<fl<< ' n';

Elementet er ikke fjernet fra vektoren.

foran () konst

Når vektorkonstruksjonen går foran const, utføres uttrykket front () const i stedet for front (). Dette brukes i følgende kode:

konstvektor<flyte>vtr{1.1, 2.2, 3.3, 4.4};
flytefl=vtr.front();
koste<<fl<< ' n';

En konstant referanse returneres. Elementet er ikke fjernet fra vektoren.

tilbake()

Dette returnerer en referanse til det siste elementet i vektoren uten å fjerne elementet. Utdataene fra følgende kode er 4.4.

vektor<flyte>vtr{1.1, 2.2, 3.3, 4.4};
flytefl=vtr.tilbake();
koste<<fl<< ' n';

tilbake () konst

Når vektorkonstruksjonen går foran const, utføres uttrykket back () const i stedet for back (). Dette brukes i følgende kode:

konstvektor<flyte>vtr{1.1, 2.2, 3.3, 4.4};
flytefl=vtr.tilbake();
koste<<fl<< ' n';

En konstant referanse returneres. Elementet er ikke fjernet fra vektoren.

Vektordatatilgang

data () noexcept; data () const noexcept;

Begge disse returnerer en peker slik at [data (), data () + størrelse ()) er et gyldig område.

Dette vil bli dekket mer detaljert senere i artikkelen.

Returnerende Iteratorer og vektoren

En iterator er som en peker, men har mer funksjonalitet enn en peker.

begin () noexcept

Returnerer en iterator som peker til det første elementet i vektoren, som i følgende kodesegment:

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

Utgangen er 1,1. Vær oppmerksom på at erklæringen som mottar iteratoren er erklært. Iteratoren blir referert i et returuttrykk for å få verdien på samme måte som en peker blir referert.

begin () const noexcept;

Returnerer en iterator som peker til det første elementet i vektoren. Når vektorkonstruksjonen går foran const, utføres uttrykket begin () const i stedet for begynner (). Under denne betingelsen kan ikke det tilsvarende elementet i vektoren endres. Dette brukes i følgende kode:

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

Utgangen er 1,1. Vær oppmerksom på at const_iterator har blitt brukt denne gangen i stedet for bare iterator for å motta den returnerte iteratoren.

slutten () noe unntatt

Returnerer en iterator som peker umiddelbart utover det siste elementet i vektoren. Vurder følgende kodesegment:

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

Utgangen er 0, noe som er meningsløst, siden det ikke er noe konkret element utover det siste elementet.

ende () const noexcept

Returnerer en iterator som peker umiddelbart utover det siste elementet i vektoren. Når vektorkonstruksjonen går foran const, utføres uttrykket end () const i stedet for end (). Vurder følgende kodesegment:

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

Utgangen er 0. Vær oppmerksom på at const_iterator har blitt brukt denne gangen i stedet for bare iterator for å motta den returnerte iteratoren.

Omvendt iterasjon

Det er mulig å ha en iterator som gjentar seg fra slutten til like før det første elementet.

rbegin () noe unntatt

Returnerer en iterator som peker til det siste elementet i vektoren, som i følgende kodesegment:

vektor<flyte>vtr{1.1, 2.2, 3.3, 4.4};
vektor<flyte> ::reverse_iteratorrIter=vtr.begynte på nytt();
koste<< *rIter<< ' n';

Utgangen er 4,4.

Vær oppmerksom på at erklæringen som mottar omvendt iterator er blitt erklært. Iteratoren blir referert i et returuttrykk for å få verdien på samme måte som en peker blir referert.

rbegin () const noexcept;

Returnerer en iterator som peker til det siste elementet i vektoren. Når vektorkonstruksjonen går foran const, utføres uttrykket rbegin () const i stedet for rbegin (). Under denne betingelsen kan ikke det tilsvarende elementet i vektoren endres. Denne funksjonen brukes i følgende kode:

konstvektor<flyte>vtr{1.1, 2.2, 3.3, 4.4};
vektor<flyte> ::const_reverse_iteratorrIter=vtr.begynte på nytt();
koste<< *rIter<< ' n';

Utgangen er 4,4.

Vær oppmerksom på at const_reverse_iterator har blitt brukt denne gangen, i stedet for bare reverse_iterator, for å motta den returnerte iteratoren.

gjengi () noe unntatt

Returnerer en iterator som peker like før det første elementet i vektoren. Vurder følgende kodesegment:

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

Utgangen er 0, noe som er meningsløst, da det ikke er noe konkret element like før det første elementet.

gjengi () const noexcept

Returnerer en iterator som peker like før det første elementet i vektoren. Når vektorkonstruksjonen går foran const, utføres uttrykket rend () const i stedet for rend (). Vurder følgende kodesegment:

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

Utgangen er 0.

Vær oppmerksom på at const_reverse_iterator har blitt brukt denne gangen, i stedet for bare reverse_iterator, for å motta den returnerte iteratoren.

Vektormodifikatorer

En modifikator som modifiserer vektoren kan ta eller returnere en iterator.

a. modell (s, args)

Setter inn et objekt av type T konstruert med std :: forward (args) ... før s.

For detaljer - se senere

insert (iteratorPosition, verdi)

Setter inn en kopi av verdien ved vektorens iteratorposisjon. Returnerer iteratoren (posisjonen) i vektoren der kopien er plassert. Følgende kode viser hvor verdien er plassert:

vektor<int>vtr{10, tjue, 30, 40};
vektor<int> ::iteratoriter=vtr.begynne();
++iter;
++iter;
vtr.sett inn(iter, 25);
koste<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3] << ' n';

Utgangen er: 20 25 30.

Vær oppmerksom på at iteratoren var avansert (inkrementert) akkurat som en peker.

En initialiseringsliste kan også settes inn, slik følgende kode illustrerer:

vektor<int>vtr{10, tjue, 30, 40};
vektor<int> ::iteratoriter=vtr.begynne();
++iter;
++iter;
vtr.sett inn(iter, {25, 28});

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

Utgangen er: 20 25 28 30.

slette (posisjon)

Fjerner et element i posisjonen som iteratoren peker på, og returnerer deretter iteratorposisjonen. Følgende kode illustrerer dette:

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

Utgangen er: 10 20 40

push_back (t), push_back (rv)

Brukes til å legge til et enkelt element på slutten av vektoren. Bruk push_back (t) som følger:

vektor<flyte>vtr{1.1, 2.2, 3.3, 4.4};
vtr.push_back(5.5);
flytefl=vtr[4];
koste<<fl<< ' n';

Utgangen er 5,5.

push_back(rv): -ser senere.

pop_back ()

Fjerner det siste elementet uten å returnere det. Størrelsen på vektoren reduseres med 1. Følgende kode illustrerer dette:

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

Utgangen er 3.

a. bytte (b)

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

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

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

Utgangen er:

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

Vær oppmerksom på at lengden på en vektor er økt om nødvendig. Verdier som ikke hadde erstatninger, blir også erstattet av en standardverdi.

klar()

Fjerner alle elementene fra vektoren, slik følgende kodesegment illustrerer:

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

Utgangen er 0.

Likestillings- og relasjonsoperatører for vektorer

== Operatøren

Returnerer 1 for true hvis de to vektorene har samme størrelse og de tilsvarende elementene er like; ellers returnerer det 0 for usant. For eksempel:

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

Utgangen er 0.

! = Operatøren

Returnerer 1 for true hvis de to vektorene ikke har samme størrelse og/eller de tilsvarende elementene ikke er like; ellers returnerer det 0 for usant. For eksempel:

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

Utgangen er 1.

De

Returnerer 1 for true hvis den første vektoren er den første delen av den andre vektoren, med elementene i de to like delene som er like og i samme rekkefølge. Hvis begge vektorene er av samme størrelse og beveger seg fra venstre til høyre, og et element oppstår i den første vektoren som er mindre enn det tilsvarende elementet i den andre vektoren, vil 1 fortsatt bli returnert. 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';

Utgangen er 1.

Operatøren

Returnerer! (U

De<= Operator

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

Operatøren> =

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

Konklusjon

En vektor er et eksempel på en sekvensbeholder. En vektor er en bedre form for den vanlige matrisen og er instansert fra en klasse. Vektorer har metoder som er klassifisert under: konstruksjon og tildeling, kapasitet, elementtilgang, datatilgang, iteratorer, modifikatorer og numeriske overbelastede operatører.

Det er andre sekvensbeholdere, kalt liste, forward_list og array. Hvis oppgaven innebærer hyppige innsetting og sletting i midten av sekvensen, bør en liste eller fremoverliste brukes. Hvis oppgaven innebærer hyppige innsetting og sletting i begynnelsen eller slutten av sekvensen, bør en deque brukes. Og så bør vektorer bare brukes når slike operasjoner ikke er viktige.