Hur man använder C ++ Vector

Introduktion

En array är en serie av samma objekttyper i på varandra följande minnesplatser. En grupp kan inte öka malmens längd. En vektor är som en matris, men dess längd kan ökas eller minskas. En vektor har därför många fler operationer än en matris.

C ++ har många bibliotek, som alla utgör C ++ - standardbiblioteket. Ett av dessa bibliotek är containerbiblioteket. En container är en samling objekt och vissa operationer kan utföras på samlingen. C ++ behållare kan grupperas i två uppsättningar: sekvensbehållare och associerande behållare. Sekvensbehållare är vektor, array (inte samma array som diskuterats tidigare), deque, forward_list och list. Dessa är olika samlingar (arrayliknande datastrukturer), och alla erbjuder olika avvägningar.

Alla programmerare borde veta hur de ska bestämma om de ska använda en vektor, en array, en deque, en forward_list eller en lista. När en programmerare behöver en struktur som kräver fler operationer än de som är associerade med en vanlig matris, bör den vanliga matrisen inte användas.

Om uppgiften innebär frekventa infogningar och raderingar i mitten av sekvensen bör en lista eller framåtlista användas. Om uppgiften involverar frekventa infogningar och raderingar i början eller slutet av en sekvens, bör en dekal användas. En vektor bör användas när den här typen av operationer inte krävs.

Den här artikeln visar hur du använder C ++ -vektorn. Du behöver lite kunskap om C ++ - pekare, referenser och matriser för att förstå den här artikeln.

Klass och objekt

En klass är en uppsättning variabler och funktioner som fungerar tillsammans, där variablerna inte har tilldelade värden. När värden tilldelas variablerna blir en klass ett objekt. Olika värden som ges till samma klass resulterar i olika objekt; det vill säga olika objekt kan vara av samma klass men ha olika värden. Att skapa ett objekt från en klass kallas också för att instantiera objektet.

Termen vektor beskriver en klass. Ett objekt som skapats från en vektor har ett namn som väljs av programmeraren.

En funktion som tillhör en klass behövs för att instantiera ett objekt från klassen. I C ++ har den funktionen samma namn som namnet på klassen. Olika objekt som skapats (instantierats) från klassen har olika namn som programmeraren har gett var och en av dem.

Att skapa ett objekt från en klass betyder att konstruera objektet; det betyder också att man ska starta objektet.

Vektorklassen

Vektorklassen har redan definierats och finns i biblioteket. För att kunna använda vektorklassen måste en programmerare inkludera vektorhuvudet i filen med följande förbehandlingsdirektiv:

#omfatta

När rubriken är inkluderad blir alla vektorfunktioner (datamedlemmar och medlemsfunktioner) tillgängliga. För att använda räkneobjektet för att mata ut data till terminalen (konsolen) måste objektrubriken också inkluderas. För att skriva ett program med vektorn måste minst följande rubriker inkluderas:

#omfatta
#omfatta

Instantiering av en vektor

int foo [10];

Ovan är deklarationen för en matris med namnet "foo" och antalet element "10.”Detta är en rad heltal. Deklarationen av en vektor är liknande. För en vektor är antalet element valfritt, eftersom vektorn kan öka eller minska.

Vid denna punkt i programmet har vektorklassen redan definierats i biblioteket och rubriken har inkluderats. Vektorn kan instansieras enligt följande:

std :: vektor vtr (8);

Här är vektorn för den speciella konstruktorfunktionen. Typen av data som vektorn kommer att innehålla är "int" inom vinkelparenteser. Termen “vtr” är det namn som programmeraren valt för vektorn. Slutligen är "8" inom parentes det preliminära antalet heltal som vektorn kommer att ha.

Termen "std" står för standard namnområde. Denna term måste följas av en dubbel kolon i detta sammanhang. Vem som helst kan skriva sitt eget vektorklassbibliotek och använda det. C ++ har dock redan ett standardbibliotek med standardnamn, inklusive “vector.”För att använda ett standardnamn måste standardnamnet föregås av std :: . För att undvika att skriva std :: varje gång i programmet för ett standardnamn kan programfilen starta enligt följande:

#omfatta
#omfatta
använder namnrymd std;

Överbelastning av en funktion

När två eller flera olika funktionssignaturer har samma namn, sägs det namnet vara överbelastat. När en funktion anropas bestämmer antalet och typen av argument vilken funktion som körs.

Konstruera en vektor

Att konstruera en vektor innebär att man skapar (skapar) ett vektorobjekt. Konstruktorfunktionen är överbelastad enligt följande:

vektor namn

Detta skapar en vektor med längden noll och typ “T.”Följande uttalande skapar en vektor med noll längd av typen” flyta ”med namnet“ vtr: ”

vektor vtr;

vektor namn (n)

Detta skapar en vektor med n element av typen “T.”Ett uttalande för denna vektor med fyra flottörelement är som följer:

vektor vtr (4);

vektor namn (n, t)

Detta skapar en vektor av n element initialiserade till värdet t. Följande uttalande skapar en vektor med 5 element, där varje element har värdet 3.4:

vektor vtr (5, 3.4);

Konstruktion med initialisering

En vektor kan konstrueras (skapas) och initieras samtidigt på ett av följande två sätt:

vektor vtr = 1.1, 2.2, 3.3, 4.4;

Eller

vektor vtr 1.1, 2.2, 3.3, 4.4;

Observera att det inte finns några parenteser precis efter objektnamnet. Parenteser som används strax efter objektnamnet bör ha initialiseringslistan enligt följande:

vektor vtr (1.1, 2.2, 3.3, 4.4);

En vektor kan konstrueras och initieras senare med initialiseringslistan. I det här fallet kommer inte parenteserna att användas:

vektor vtr;
vtr = 1.1, 2.2, 3.3, 4.4;

vektor V2 (V1)

Detta är en kopiekonstruktör. Det skapar en vektor V2 som en kopia av vektorn V1. Följande kod illustrerar detta:

vektor vtr1 (5, 3.4);
vektor vtr2 (vtrl);

Tilldela en vektor under konstruktion

Under konstruktionen kan en tom vektor skapas medan en annan tilldelas den enligt följande:

vektor vtr1 1.1, 2.2, 3.3, 4.4;
vektor vtr2 = vtrl;

Det andra uttalandet motsvarar:

vektor vtr2 = 1.1, 2.2, 3.3, 4.4;

const Vector

En konstvektor är en vektor vars element inte kan ändras. Värdena i denna vektor är skrivskyddade. När den skapas visas vektorn enligt följande:

const vektor vtr 1.1, 2.2, 3.3, 4.4;

I denna vektortyp kan inget element läggas till eller tas bort. Dessutom kan inget värde ändras.

Konstruktion med Iterator

En mall ger en generell representation för en datatyp. En iterator ger en generell representation av skanning genom värdena för en behållare. Syntaxen för att skapa en vektor med en iterator är som följer:

mall
vektor (InputIterator först, InputIterator sist, const Allocator & = Allocator ());

Detta konstruerar en vektor för intervallet [första, sista) med den angivna fördelaren, som kommer att diskuteras senare i den här artikeln.

Förstör en vektor

För att förstöra en vektor, låt den helt enkelt gå utanför räckvidden och förstör hanteras automatiskt.

Vektorkapacitet

storlek_typ kapacitet () const noexcept

Det totala antalet element som vektorn kan hålla utan att omfördelning krävs returneras av kapacitetsmedlemfunktionen. Ett kodsegment för detta är som följer:

vektor vtr (4);
int num = vtr.kapacitet();
cout << num << '\n';

Utgången är 4.

reserv (n)

Minnesutrymme är inte alltid fritt tillgängligt. Extra utrymme kan reserveras i förväg. Tänk på följande kodsegment:

vektor vtr (4);
vtr.reserv (6);
cout << vtr.capacity() << '\n';

Utgången är 6. Så det extra reserverade utrymmet är 6 - 4 = 2 element. Funktionen returnerar ogiltig.

storlek () const noexcept

Detta returnerar antalet element i vektorn. Följande kod illustrerar denna funktion:

vektor vtr (4);
flyta sz = vtr.storlek();
cout << sz << '\n';

Utgången är 4.

krymp för att passa()

Efter att ha gett extra kapacitet till en vektor med funktionen reserve () kan vektorn dimensioneras så att den passar till sin ursprungliga storlek. Följande kod illustrerar detta:

vektor vtr (4);
vtr.reserv (6);
vtr.krymp för att passa();
int sz = vtr.storlek();
cout << sz << '\n';

Utgången är 4 och inte 6. Funktionen returnerar ogiltig.

ändra storlek (sz), ändra storlek (sz, c)

Detta ändrar storleken på vektorn. Om den nya storleken är mindre än den gamla storleken raderas elementen mot slutet. Om den nya storleken är längre läggs ett visst standardvärde till i slutet. För att ha ett visst tillagt värde, använd resize () -funktionen med två argument. Följande kodsegment illustrerar användningen av dessa två funktioner:

vektor vtr1 1.1, 2.2, 3.3, 4.4;
vtr1.ändra storlek (2);
cout << "New size of vtr1: " << vtr1.size() << '\n';
vektor vtr2 1.1, 2.2;
vtr2.ändra storlek (4, 8.8);
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

Resultatet är följande:

Ny storlek på vtr1: 2
vtr2: 1.1 2.2 8.8 8.8

Funktionerna återgår ogiltiga.

tom () const noexcept

Denna funktion returnerar 1 för true om det inte finns några element i vektorn och 0 för false om vektorn är tom. Om en vektor har fyra platser för en viss typ av data, som float, utan något floatvärde, är den vektorn inte tom. Följande kod illustrerar detta:

vektor vtr;
cout << vtr.empty() << '\n';
vektor vt (4);
cout << vt.empty() << '\n';
vektor v (4,3.5);
cout << v.empty() << '\n';

Resultatet är följande:

1
0
0

Vector Element Access

En vektor kan undertecknas (indexeras) som en matris. Indexräkningen börjar från noll.

vectorName [i]

Operationen "vectorName [i]" returnerar en referens till elementet vid i^th index för vektorn. Följande kodutgångar 3.3 för ovanstående vektor:

vektor vtr 1.1, 2.2, 3.3, 4.4;
flottör fl = vtr [2];
cout << fl << '\n';

vectorName [i] konst

Operationen "vectorName [i] const" körs istället för "vectorName [i]" när vektorn är en konstant vektor. Denna åtgärd används i följande kod:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
flottör fl = vtr [2];
cout << fl << '\n';

Uttrycket returnerar en konstant hänvisning till i^th element av vektorn.

Tilldela ett värde med prenumeration

Ett värde kan tilldelas en icke-konstant vektor enligt följande:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr [2] = 8.8;
cout << vtr[2] << '\n';

Utgången är 8.8.

vectorName.vid (i)

“VectorName.vid (i) ”är som“ vectorName [i], ”men“ vectorName.at (i) ”är mer tillförlitlig. Följande kod visar hur denna vektor ska användas:

vektor vtr 1.1, 2.2, 3.3, 4.4;
flyta fl = vtr.vid (2);
cout << fl << '\n';
at () är en vektormedelfunktion.

vectorName.vid (i) konst

“VectorName.at (i) const ”är som“ vectorName [i] const ”, men“ vectorName.at (i) const ”är mer tillförlitlig. “VectorName.at (i) const ”körs istället för“ vectorName.vid (i) ”när vektorn är en konstant vektor. Denna vektor används i följande kod:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
flyta fl = vtr.vid (2);
cout << fl << '\n';
at () const är en vektormedelfunktion.

Tilldela ett värde med funktionen at ()

Ett värde kan tilldelas en icke-konstant vektor med funktionen at () enligt följande:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.vid (2) = 8.8;
cout << vtr[2] << '\n';

Utgången är 8.8.

Problem med underskriptning

Problemet med underskriptning (indexering) är att om indexet är utanför intervallet kan noll returneras eller ett fel kan utfärdas vid körning.

främre()

Detta returnerar en referens till det första elementet i vektorn utan att ta bort elementet. Utgången för följande kod är 1.1.

vektor vtr 1.1, 2.2, 3.3, 4.4;
flyta fl = vtr.främre();
cout << fl << '\n';

Elementet tas inte bort från vektorn.

främre () konst

När vektorkonstruktionen föregås av const utförs uttrycket "front () const" istället för "front ().”Detta används i följande kod:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
flyta fl = vtr.främre();
cout << fl << '\n';

En konstant referens returneras. Elementet tas inte bort från vektorn.

tillbaka()

Detta returnerar en referens till det sista elementet i vektorn utan att ta bort elementet. Utgången för följande kod är 4.4.

vektor vtr 1.1, 2.2, 3.3, 4.4;
flyta fl = vtr.tillbaka();
cout << fl << '\n';

tillbaka () konst

När vektorkonstruktionen föregås av const körs uttrycket "back () const" istället för "back ().”Detta används i följande kod:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
flyta fl = vtr.tillbaka();
cout << fl << '\n';

En konstant referens returneras. Elementet tas inte bort från vektorn.

Vector Data Access

data () noexcept; data () const noexcept;

Endera av dessa returnerar en pekare så att [data (), data () + storlek ()) är ett giltigt intervall.

Detta kommer att behandlas mer detaljerat senare i artikeln.

Återkommande Iteratorer och vektorn

En iterator är som en pekare men har mer funktionalitet än en pekare.

starta () noexcept

Returnerar en iterator som pekar på det första elementet i vektorn, som i följande kodsegment:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: iterator iter = vtr.Börja();
cout << *iter << '\n';

Utgången är 1.1. Observera att deklarationen som tar emot iteratorn har deklarerats. Iteratorn härleds i ett returuttryck för att erhålla värdet på samma sätt som en pekare härleds.

begin () const noexcept;

Returnerar en iterator som pekar på det första elementet i vektorn. När vektorkonstruktionen föregås av const utförs uttrycket "start () const" istället för "start ().”Under detta villkor kan motsvarande element i vektorn inte ändras. Detta används i följande kod:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: const_iterator iter = vtr.Börja();
cout << *iter << '\n';

Utgången är 1.1. Observera att "const_iterator" har använts den här gången istället för bara "iterator" för att ta emot den returnerade iteratorn.

slut () noexcept

Returnerar en iterator som pekar direkt bortom det sista elementet i vektorn. Tänk på följande kodsegment:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: iterator iter = vtr.slutet();
cout << *iter << '\n';

Utgången är 0, vilket är meningslöst, eftersom det inte finns något konkret element utöver det sista elementet.

end () const noexcept

Returnerar en iterator som pekar omedelbart bortom det sista elementet i vektorn. När vektorkonstruktionen föregås av "const" utförs uttrycket "end () const" istället för "end ().”Tänk på följande kodsegment:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: const_iterator iter = vtr.slutet();
cout << *iter << '\n';

Utgången är 0. Observera att "const_iterator" har använts den här gången istället för bara "iterator" för att ta emot den returnerade iteratorn.

Omvänd itteration

Det är möjligt att ha en iterator som itererar från slutet till strax före det första elementet.

rbegin () noexcept

Returnerar en iterator som pekar på det sista elementet i vektorn, som i följande kodsegment:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: reverse_iterator rIter = vtr.rbegin ();
cout << *rIter << '\n';

Utgången är 4.4.

Observera att deklarationen som tar emot omvänd iterator har deklarerats. Iteratorn härleds i ett returuttryck för att erhålla värdet på samma sätt som en pekare härleds.

rbegin () const noexcept;

Returnerar en iterator som pekar på det sista elementet i vektorn. När vektorkonstruktionen föregås av "const" körs uttrycket "rbegin () const" istället för "rbegin ().”Under detta villkor kan motsvarande element i vektorn inte ändras. Den här funktionen används i följande kod:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: const_reverse_iterator rIter = vtr.rbegin ();
cout << *rIter << '\n';

Utgången är 4.4.

Observera att const_reverse_iterator har använts den här gången, istället för bara reverse_iterator, för att ta emot den returnerade iteratorn.

rend () noexcept

Returnerar en iterator som pekar strax före det första elementet i vektorn. Tänk på följande kodsegment:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: reverse_iterator rIter = vtr.rämna();
cout << *rIter << '\n';

Utgången är 0, vilket är meningslöst, eftersom det inte finns något konkret element strax före det första elementet.

rend () const noexcept

Returnerar en iterator som pekar strax före det första elementet i vektorn. När vektorkonstruktionen föregås av "const" utförs uttrycket "rend () const" istället för "rend ().”Tänk på följande kodsegment:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: const_reverse_iterator rIter = vtr.rämna();
cout << *rIter << '\n';

Utgången är 0.

Observera att const_reverse_iterator har använts den här gången, istället för bara reverse_iterator, för att ta emot den returnerade iteratorn.

Vector modifierare

En modifierare som modifierar vektorn kan ta eller returnera en iterator.

a.emplace (p, args)

Infogar ett objekt av typen T konstruerat med std :: framåt(args) ... före s.

För detaljer - se senare

infoga (iteratorPosition, värde)

Infogar en kopia av värdet i vektorn iteratorposition. Returnerar iteratorn (position) i vektorn där kopian har placerats. Följande kod visar var värdet har placerats:

vektor vtr 10, 20, 30, 40;
vektor:: iterator iter = vtr.Börja();
++iter;
++iter;
vtr.infoga (iter, 25);
cout << vtr[1] << " << vtr[2]<< '
'' << vtr[3] << '\n';

Utgången är: 20 25 30.

Observera att iteratorn var avancerad (inkrementerad) precis som en pekare.

En initialiseringslista kan också infogas, som följande kod illustrerar:

vektor vtr 10, 20, 30, 40;
vektor:: iterator iter = vtr.Börja();
++iter;
++iter;
vtr.infoga (iter, 25, 28);
cout << vtr[1] << " << vtr[2]<< '
'' << vtr[3]<< " << vtr[4] << '\n';

Utgången är: 20 25 28 30.

radera (position)

Tar bort ett element i det läge som iteratorn pekar på och returnerar sedan iteratorpositionen. Följande kod illustrerar detta:

vektor vtr 10, 20, 30, 40;
vektor:: iterator iter = vtr.Börja();
++iter;
++iter;
vtr.radera (iter);
cout << vtr[0] << " << vtr[1] << '
'' << vtr[2]<< '\n';

Utgången är: 10 20 40

push_back (t), push_back (rv)

Används för att lägga till ett enda element i slutet av vektorn. Använd push_back (t) enligt följande:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.push_back (5.5);
flottör fl = vtr [4];
cout << fl << '\n';

Utgången är 5.5.

push_back (rv): - se senare.

pop_back ()

Tar bort det sista elementet utan att returnera det. Storleken på vektorn minskas med 1. Följande kod illustrerar detta:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.pop_back ();
flyta sz = vtr.storlek();
cout << sz << '\n';

Utgången är 3.

a.byta (b)

Två vektorer kan bytas ut, som illustreras i följande kodsegment:

vektor vtr1 1.1, 2.2, 3.3, 4.4;
vektor vtr2 10, 20;
vtr1.byta (vtr2);
cout << "vtr1: "<< vtr1[0] <<" "<< vtr1[1] <<"
"<< vtr1[2] <<" "<< vtr1[3] << '\n';
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

Utgången är:

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

Observera att längden på en vektor ökas vid behov. Värden som inte har ersatt ersätts också med något standardvärde.

klar()

Tar bort alla element från vektorn, som följande kodsegment illustrerar:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.klar();
cout << vtr.size() << '\n';

Utgången är 0.

Jämställdhets- och relationsoperatörer för vektorer

Operatören ==

Returnerar 1 för true om de två vektorerna har samma storlek och motsvarande element är lika; annars returnerar den 0 för falskt. Till exempel:

vektor U 1, 2, 3;
vektor V 4, 5, 6;
bool bl = U == V;
cout << bl << '\n';

Utgången är 0.

De != Operatör

Returnerar 1 för true om de två vektorerna inte har samma storlek och / eller motsvarande element inte är lika; annars returnerar den 0 för falskt. Till exempel:

vektor U 1, 2, 3;
vektor V 4, 5, 6;
bool bl = U!= V;
cout << bl << '\n';

Utgången är 1.

De < Operator

Returnerar 1 för true om den första vektorn är den första delmängden av den andra vektorn, med elementen i de två lika delarna är samma och i samma ordning. Om båda vektorerna är av samma storlek och rör sig från vänster till höger och ett element påträffas i den första vektorn som är mindre än motsvarande element i den andra vektorn, kommer 1 fortfarande att returneras. Annars returneras 0 för falskt. Till exempel:

vektor U 3, 1, 1;
vektor V 3, 2, 1;
bool bl = Ucout << bl << '\n';

Utgången är 1. < does not include the case when the size and order are the same.

> Operatören

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

De <= Operator

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

Operatören> =

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

Slutsats

En vektor är ett exempel på en sekvensbehållare. En vektor är en ”bättre” form av den ordinarie matrisen och instanseras från en klass. Vektorer har metoder som klassificeras under: konstruktion och tilldelning, kapacitet, elementåtkomst, dataåtkomst, iteratorer, modifierare och numeriska överbelastade operatörer.

Det finns andra sekvensbehållare, som kallas list, forward_list och array. Om uppgiften innebär frekventa infogningar och raderingar i mitten av sekvensen bör en lista eller framåtlista användas. Om uppgiften involverar frekventa infogningar och raderingar i början eller slutet av sekvensen bör en deque användas. Och så bör vektorer endast användas när denna typ av operationer inte är viktiga.