Kuinka käyttää C ++ Vectoria

How Use C Vector

Johdanto

Taulukko on sarja samoja objektityyppejä peräkkäisissä muistipaikoissa. Matriisi ei voi lisätä malmin pituutta. Vektori on kuin matriisi, mutta sen pituutta voidaan lisätä tai pienentää. Vektorilla on siis paljon enemmän toimintoja kuin taulukko.

C ++: ssa on monia kirjastoja, jotka kaikki muodostavat C ++ -kirjaston. Yksi näistä kirjastoista on säilökirjasto. Säiliö on kokoelma esineitä, ja kokoelmaan voidaan suorittaa tiettyjä toimintoja. C ++ -säiliöt voidaan ryhmitellä kahteen ryhmään: sekvenssisäiliöt ja assosiatiiviset säiliöt. Sekvenssisäiliöt ovat vektori, taulukko (ei sama taulukko, josta keskusteltiin aiemmin), deque, forward_list ja list. Nämä ovat erilaisia ​​kokoelmia (matriisin kaltaisia ​​tietorakenteita), ja kukin niistä tarjoaa selkeitä kompromisseja.



Kaikkien ohjelmoijien tulisi tietää, miten päättää, käytetäänkö vektoria, matriisia, dekkiä, eteenpäin_listaa vai luetteloa. Kun ohjelmoija tarvitsee rakennetta, joka vaatii enemmän toimintoja kuin tavalliseen matriisiin liittyvät toiminnot, tavallista taulukkoa ei tule käyttää.



Jos tehtävään liittyy usein lisäyksiä ja poistoja sekvenssin keskelle, on käytettävä luetteloa tai eteenpäin_listaa. Jos tehtävä sisältää usein lisäyksiä ja poistoja sarjan alussa tai lopussa, on käytettävä dekkiä. Vektoria tulisi käyttää, kun tällaisia ​​toimintoja ei vaadita.



Tämä artikkeli näyttää kuinka käyttää C ++ -vektoria. Tarvitset jonkin verran tietoa C ++ -osoittimista, viitteistä ja matriiseista tämän artikkelin ymmärtämiseksi.

Luokka ja esineet

Luokka on joukko muuttujia ja funktioita, jotka toimivat yhdessä ja joissa muuttujille ei ole määritetty arvoja. Kun muuttujille on määritetty arvot, luokasta tulee objekti. Samalle luokalle annetut eri arvot johtavat eri objekteihin; eli eri objektit voivat olla samaa luokkaa, mutta niillä voi olla eri arvot. Objektin luominen luokasta tunnetaan myös nimellä objektin luominen.

Termi vektori kuvaa luokkaa. Vektorista luodulla objektilla on ohjelmoijan valitsema nimi.



Luokkaan kuuluva funktio tarvitaan objektin luontiin luokasta. C ++: ssa kyseisellä funktiolla on sama nimi kuin luokan nimellä. Eri luokasta luotuilla (näytteillä olevilla) objekteilla on eri nimet, jotka ohjelmoija on antanut kullekin niistä.

Objektin luominen luokasta tarkoittaa objektin rakentamista; se tarkoittaa myös kohteen näyttämistä.

Vektoriluokka

Vektoriluokka on jo määritetty ja se on kirjastossa. Vektoriluokan käyttämiseksi ohjelmoijan on sisällytettävä vektoriotsikko tiedostoon seuraavan esikäsittelydirektiivin kanssa:

#sisältää

Kun otsikko on sisällytetty, kaikki vektoriominaisuudet (datajäsenet ja jäsentoiminnot) ovat käytettävissä. Jos haluat käyttää laskentaobjektia datan tulostamiseen päätelaitteeseen (konsoliin), myös objektin otsikko on sisällytettävä. Ohjelman kirjoittamiseksi vektorin kanssa on sisällytettävä vähintään seuraavat otsikot:

#sisältää
#sisältää

Vektorin asentaminen

intfoo[10];

Yllä on taulukon ilmoitus, jonka nimi on foo ja elementtien määrä 10. Tämä on kokonaislukujen taulukko. Vektorin ilmoitus on samanlainen. Vektorille elementtien määrä on valinnainen, koska vektorin pituus voi kasvaa tai pienentyä.

Ohjelman tässä vaiheessa vektoriluokka on jo määritetty kirjastossa ja otsikko on sisällytetty. Vektori voidaan ilmentää seuraavasti:

tuntia::vektori <int>vtr(8);

Tässä vektorissa on erityinen konstruktoritoiminto. Vektorin säilyttämät tiedot ovat int, kulmasulkeissa. Termi vtr on ohjelmoijan valitsema nimi vektorille. Lopuksi 8 suluissa on alustava kokonaislukujen määrä, joka vektorilla on.

Termi std tarkoittaa tavallista nimiavaruutta. Tässä yhteydessä termiä on seurattava kaksoispiste. Kuka tahansa voi kirjoittaa oman vektoriluokkakirjastonsa ja käyttää sitä. C ++: lla on kuitenkin jo vakiokirjasto, jossa on vakionimet, mukaan lukien vektori. Vakionimen käyttäminen edellyttää, että standardinimen edessä on oltava std ::. Välttääksesi std ::: n kirjoittamisen joka kerta, kun ohjelmassa on vakionimi, ohjelmatiedosto voi alkaa seuraavasti:

#sisältää
#sisältää
käyttämällä nimiavaruuden std;

Toiminnon ylikuormitus

Kun kahdella tai useammalla eri funktion allekirjoituksella on sama nimi, sen sanotaan olevan ylikuormitettu. Kun yksi funktio kutsutaan, argumenttien lukumäärä ja tyyppi määrittävät suoritettavan funktion.

Vektorin rakentaminen

Vektorin luominen tarkoittaa vektoriobjektin hetkellistämistä (luomista). Rakennustoiminto ylikuormitetaan seuraavasti:

vektorin nimi

Tämä luo vektorin, jonka pituus on nolla ja tyyppi T.

vektori<kellua>vtr;

vektorin nimi (n)

Tämä luo vektorin, jossa on n tyyppiä T.

vektori<kellua>vtr(4);

vektorin nimi (n, t)

Tämä luo v: n elementin vektorin, joka on alustettu arvoon t. Seuraava lause luo 5 elementin vektorin, jossa jokaisella elementillä on arvo 3,4:

vektori<kellua>vtr(5, 3.4);

Rakentaminen alustuksella

Vektori voidaan rakentaa (luoda) ja alustaa samanaikaisesti jollakin seuraavista tavoista:

vektori<kellua>vtr= {1.1, 2.2, 3.3, 4.4};

Tai

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};

Huomaa, että sulkuja ei ole juuri objektin nimen jälkeen. Heti objektin nimen jälkeen käytetyissä suluissa on oltava alustusluettelo seuraavasti:

vektori<kellua>vtr({1.1, 2.2, 3.3, 4.4});

Vektori voidaan rakentaa ja alustaa myöhemmin alustusluettelon avulla. Tässä tapauksessa sulkeita ei käytetä:

vektori<kellua>vtr;
vtr= {1.1, 2.2, 3.3, 4.4};

vektori V2 (V1)

Tämä on kopiorakentaja. Se luo vektorin V2 kopioksi vektorista V1. Seuraava koodi havainnollistaa tätä:

vektori<kellua>vtr1(5, 3.4);
vektori<kellua>vtr2(vtr1);

Vektorin määrittäminen rakentamisen aikana

Rakentamisen aikana voidaan luoda tyhjä vektori, kun sille annetaan toinen, seuraavasti:

vektori<kellua>vtr1{1.1, 2.2, 3.3, 4.4};
vektori<kellua>vtr2=vtr1;

Toinen väite vastaa:

vektori<kellua>vtr2= {1.1, 2.2, 3.3, 4.4};

const vektori

Const -vektori on vektori, jonka elementtejä ei voi muuttaa. Tämän vektorin arvot ovat vain luku -tilassa. Luotu vektori näkyy seuraavasti:

constvektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};

Tässä vektorityypissä elementtiä ei voi lisätä tai poistaa. Lisäksi mitään arvoa ei voi muuttaa.

Rakentaminen Iteratorilla

Malli tarjoaa tietotyypille yleisen esityksen. Iteraattori tarjoaa yleisen esityksen säilön arvojen läpi skannaamisesta. Vektori, jossa on iteraattori, syntaksi on seuraava:

sapluuna<luokan InputIterator>
vektori(InputIterator ensin,InputIterator viimeisenä,constJakaja& =Jakaja());

Tämä muodostaa vektorin alueelle [ensimmäinen, viimeinen] käyttämällä määritettyä allokoijaa, jota käsitellään myöhemmin tässä artikkelissa.

Vektorin tuhoaminen

Jos haluat tuhota vektorin, anna sen yksinkertaisesti mennä soveltamisalan ulkopuolelle ja tuhoaminen käsitellään automaattisesti.

Vektorikapasiteetti

size_type capacity () const noexcept

Kapasiteettifunktio palauttaa vektorin sisältämien elementtien kokonaismäärän ilman uudelleenkohdistusta. Koodisegmentti tälle on seuraava:

vektori<kellua>vtr(4);
intyhdellä=vtr.kapasiteettia();
kustannus<<yhdellä<< '' n'';

Lähtö on 4.

varaus (n)

Muistitila ei ole aina vapaasti käytettävissä. Lisätilaa voi varata etukäteen. Harkitse seuraavaa koodisegmenttiä:

vektori<kellua>vtr(4);
vtr.varata(6);
kustannus<<vtr.kapasiteettia() << '' n'';

Lähtö on 6. Joten varattu ylimääräinen tila on 6 - 4 = 2 elementtiä. Funktio palauttaa mitätön.

size () const noexcept

Tämä palauttaa vektorin elementtien määrän. Seuraava koodi kuvaa tätä toimintoa:

vektori<kellua>vtr(4);
kelluas=vtr.koko();
kustannus<<s<< '' n'';

Lähtö on 4.

kutistetaan sopivaksi()

Kun vektorille on annettu lisäkapasiteettia varaus () -funktiolla, vektori voidaan pienentää alkuperäiseen kokoon sopivaksi. Seuraava koodi havainnollistaa tätä:

vektori<kellua>vtr(4);
vtr.varata(6);
vtr.kutistetaan sopivaksi();
ints=vtr.koko();
kustannus<<s<< '' n'';

Lähtö on 4 eikä 6. Toiminto palauttaa mitätön.

muuttaa kokoa (sz), muuttaa kokoa (sz, c)

Tämä muuttaa vektorin kokoa. Jos uusi koko on pienempi kuin vanha koko, lopun elementit poistetaan. Jos uusi koko on pidempi, loppuun lisätään jokin oletusarvo. Jos haluat saada lisäarvoa, käytä resize () -funktiota kahdella argumentilla. Seuraava koodisegmentti kuvaa näiden kahden toiminnon käyttöä:

vektori<kellua>vtr1{1.1, 2.2, 3.3, 4.4};
vtr1.muuttaa kokoa(2);
kustannus<< 'Uusi vtr1 -koko:' <<vtr1.koko() << '' n'';
vektori<kellua>vtr2{1.1, 2.2};
vtr2.muuttaa kokoa(4, 8.8);
kustannus<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<''
''
<<vtr2[2] <<''<<vtr2[3] << '' n'';

Lähtö on seuraava:

Uusi vtr1: 2 koko
vtr2: 1.1 2.2 8.8 8.8

Toiminnot palaavat tyhjiksi.

empty () const noexcept

Tämä funktio palauttaa arvon 1 tosi, jos vektorissa ei ole elementtejä ja 0 epätosi, jos vektori on tyhjä. Jos vektorilla on 4 sijaintia tietyntyyppisille tiedoille, kuten kelluville, ilman kelluvaa arvoa, vektori ei ole tyhjä. Seuraava koodi havainnollistaa tätä:

vektori<kellua>vtr;
kustannus<<vtr.tyhjä() << '' n'';
vektori<kellua>vt(4);
kustannus<<jottatyhjä() << '' n'';

vektori<kellua>v(4,3.5);
kustannus<<v.tyhjä() << '' n'';

Lähtö on seuraava:

1
0
0

Vektorielementtien käyttö

Vektori voidaan skriptoida (indeksoida) kuten taulukko. Indeksin laskenta alkaa nollasta.

vectorName [i]

Operaatio vectorName [i] palauttaa viittauksen elementtiin i: ssäthvektorin indeksi. Seuraavat koodilähdöt 3.3 yllä olevalle vektorille:

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
kelluafl=vtr[2];
kustannus<<fl<< '' n'';

vectorName [i] const

Toiminto vectorName [i] const suoritetaan vectorName [i] -sovelluksen sijasta, kun vektori on vakiovektori. Tätä toimintoa käytetään seuraavassa koodissa:

constvektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
kelluafl=vtr[2];
kustannus<<fl<< '' n'';

Lauseke palauttaa jatkuvan viittauksen i: henthvektorin elementti.

Arvon määrittäminen alaindeksillä

Arvo voidaan määrittää ei-vakiovektorille seuraavasti:

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vtr[2] = 8.8;
kustannus<<vtr[2] << '' n'';

Tulos on 8,8.

vectorName.at (i)

vectorName.at (i) on kuin vectorName [i], mutta vectorName.at (i) on luotettavampi. Seuraava koodi näyttää, kuinka tätä vektoria tulisi käyttää:

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
kelluafl=vtr.klo(2);
kustannus<<fl<< '' n'';
klo()on vektori jäsentoiminto.

vectorName.at (i) const

vectorName.at (i) const on kuin vectorName [i] const, mutta vectorName.at (i) const on luotettavampi. vectorName.at (i) const suoritetaan vectorName.at (i) sijasta, kun vektori on vakiovektori. Tätä vektoria käytetään seuraavassa koodissa:

constvektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
kelluafl=vtr.klo(2);
kustannus<<fl<< '' n'';
klo() conston vektori jäsentoiminto.

Arvon määrittäminen at () -funktiolla

Arvo voidaan määrittää ei-vakiovektorille at () -funktiolla seuraavasti:

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vtr.klo(2) = 8.8;
kustannus<<vtr[2] << '' n'';

Tulos on 8,8.

Ongelma alikomentosarjoissa

Alikomentosarjojen (indeksoinnin) ongelma on se, että jos indeksi on alueen ulkopuolella, nolla voidaan palauttaa tai virhe voidaan antaa ajon aikana.

edestä ()

Tämä palauttaa viittauksen vektorin ensimmäiseen elementtiin poistamatta elementtiä. Seuraavan koodin tulos on 1.1.

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
kelluafl=vtr.edessä();
kustannus<<fl<< '' n'';

Elementtiä ei poisteta vektorista.

edessä () const

Kun vektorirakennetta edeltää const, lauseke front () const suoritetaan front (): n sijasta. Tätä käytetään seuraavassa koodissa:

constvektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
kelluafl=vtr.edessä();
kustannus<<fl<< '' n'';

Jatkuva viite palautetaan. Elementtiä ei poisteta vektorista.

takaisin()

Tämä palauttaa viittauksen vektorin viimeiseen elementtiin poistamatta elementtiä. Seuraavan koodin lähtö on 4.4.

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
kelluafl=vtr.takaisin();
kustannus<<fl<< '' n'';

takaisin () const

Kun vektorirakennetta edeltää const, lauseke back () const suoritetaan back (): n sijasta. Tätä käytetään seuraavassa koodissa:

constvektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
kelluafl=vtr.takaisin();
kustannus<<fl<< '' n'';

Jatkuva viite palautetaan. Elementtiä ei poisteta vektorista.

Vektoritietojen käyttö

data () noexcept; data () const noexcept;

Kumpikin näistä palauttaa osoittimen siten, että [data (), data () + size ()) on kelvollinen alue.

Tätä käsitellään tarkemmin myöhemmin artikkelissa.

Palauttavat iteraattorit ja vektori

Iteraattori on kuin osoitin, mutta sillä on enemmän toimintoja kuin osoitin.

begin () noexcept

Palauttaa iteraattorin, joka osoittaa vektorin ensimmäiseen elementtiin, kuten seuraavassa koodisegmentissä:

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vektori<kellua> ::iteraattoriiter=vtr.alkaa();
kustannus<< *iter<< '' n'';

Tulos on 1.1. Huomaa, että iteraattorin vastaanottava ilmoitus on ilmoitettu. Iteraattorin referenssit poistetaan palautuslausekkeessa arvon saamiseksi samalla tavalla kuin osoittimen poistaminen.

begin () const noexcept;

Palauttaa iteraattorin, joka osoittaa vektorin ensimmäiseen elementtiin. Kun vektorirakennetta edeltää const, lauseke begin () const suoritetaan begin () sijasta. Tässä tilanteessa vektorin vastaavaa elementtiä ei voi muuttaa. Tätä käytetään seuraavassa koodissa:

constvektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vektori<kellua> ::const_iteratoriter=vtr.alkaa();
kustannus<< *iter<< '' n'';

Tulos on 1.1. Huomaa, että const_iterator on tällä kertaa käytetty vain iteraattorin sijaan palautetun iteraattorin vastaanottamiseksi.

end () noexcept

Palauttaa iteraattorin, joka osoittaa heti vektorin viimeisen elementin ulkopuolelle. Harkitse seuraavaa koodisegmenttiä:

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vektori<kellua> ::iteraattoriiter=vtr.loppuun();
kustannus<< *iter<< '' n'';

Tulos on 0, mikä on merkityksetöntä, koska viimeisen elementin ulkopuolella ei ole konkreettista elementtiä.

end () const noexcept

Palauttaa iteraattorin, joka osoittaa heti vektorin viimeisen elementin ulkopuolelle. Kun vektorirakennetta edeltää const, lauseke end () const suoritetaan end (): n sijasta. Harkitse seuraavaa koodisegmenttiä:

constvektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vektori<kellua> ::const_iteratoriter=vtr.loppuun();
kustannus<< *iter<< '' n'';

Tulos on 0. Huomaa, että const_iterator on tällä kertaa käytetty vain iteraattorin sijaan palautetun iteraattorin vastaanottamiseksi.

Käänteinen iterointi

On mahdollista saada iteraattori, joka iteroi loppuun asti ennen ensimmäistä elementtiä.

rbegin () ei paitsi

Palauttaa iteraattorin, joka osoittaa vektorin viimeiseen elementtiin, kuten seuraavassa koodisegmentissä:

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vektori<kellua> ::reverse_iteratorisompi=vtr.rbegin();
kustannus<< *isompi<< '' n'';

Tulos on 4,4.

Huomaa, että käänteisen iteraattorin vastaanottava ilmoitus on ilmoitettu. Iteraattorin referenssit poistetaan palautuslausekkeessa arvon saamiseksi samalla tavalla kuin osoittimen poistaminen.

rbegin () const noexcept;

Palauttaa iteraattorin, joka osoittaa vektorin viimeiseen elementtiin. Kun vektorirakennetta edeltää const, lauseke rbegin () const suoritetaan rbegin (): n sijasta. Tässä tilanteessa vektorin vastaavaa elementtiä ei voi muuttaa. Tätä ominaisuutta käytetään seuraavassa koodissa:

constvektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vektori<kellua> ::const_reverse_iteratorisompi=vtr.rbegin();
kustannus<< *isompi<< '' n'';

Tulos on 4,4.

Huomaa, että Const_reverse_iterator on tällä kertaa käytetty palautetun iteraattorin sijasta vain reverse_iteratorin sijaan.

render () noexcept

Palauttaa iteraattorin, joka osoittaa juuri ennen vektorin ensimmäistä elementtiä. Harkitse seuraavaa koodisegmenttiä:

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vektori<kellua> ::reverse_iteratorisompi=vtr.tekee();
kustannus<< *isompi<< '' n'';

Tulos on 0, mikä on merkityksetöntä, koska juuri ennen ensimmäistä elementtiä ei ole konkreettista elementtiä.

render () const noexcept

Palauttaa iteraattorin, joka osoittaa juuri ennen vektorin ensimmäistä elementtiä. Kun vektorirakennetta edeltää const, lauseke rend () const suoritetaan rend (): n sijasta. Harkitse seuraavaa koodisegmenttiä:

constvektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vektori<kellua> ::const_reverse_iteratorisompi=vtr.tekee();
kustannus<< *isompi<< '' n'';

Lähtö on 0.

Huomaa, että Const_reverse_iterator on tällä kertaa käytetty palautetun iteraattorin sijasta vain reverse_iteratorin sijaan.

Vektorin muokkaajat

Muokkaaja, joka muuttaa vektoria, voi ottaa tai palauttaa iteraattorin.

a. malli (p, args)

Lisää tyypin T objektin, joka on rakennettu std :: eteenpäin (args)… ennen s.

Lisätietoja - katso myöhemmin

lisää (iteratorPosition, value)

Lisää kopion arvosta vektorin iterointipaikkaan. Palauttaa iteraattorin (sijainnin) vektorissa, johon kopio on sijoitettu. Seuraava koodi näyttää, mihin arvo on sijoitettu:

vektori<int>vtr{10, kaksikymmentä, 30, 40};
vektori<int> ::iteraattoriiter=vtr.alkaa();
++iter;
++iter;
vtr.lisää(iter, 25);
kustannus<<vtr[1] << '' <<vtr[2]<< ''
''
<<vtr[3] << '' n'';

Tulos on: 20 25 30.

Huomaa, että iteraattori oli edistynyt (lisätty) aivan kuten osoitin.

Alusteluettelo voidaan myös lisätä, kuten seuraava koodi havainnollistaa:

vektori<int>vtr{10, kaksikymmentä, 30, 40};
vektori<int> ::iteraattoriiter=vtr.alkaa();
++iter;
++iter;
vtr.lisää(iter, {25, 28});

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

Tulos on: 20 25 28 30.

poistaa (sijainti)

Poistaa elementin iteraattorin osoittamasta kohdasta ja palauttaa sitten iteraattorin asennon. Seuraava koodi havainnollistaa tätä:

vektori<int>vtr{10, kaksikymmentä, 30, 40};
vektori<int> ::iteraattoriiter=vtr.alkaa();
++iter;
++iter;
vtr.poistaa(iter);
kustannus<<vtr[0] << '' <<vtr[1] << ''
''
<<vtr[2]<< '' n'';

Tulos on: 10 20 40

push_back (t), push_back (rv)

Käytetään yhden elementin lisäämiseen vektorin loppuun. Käytä push_back (t) -järjestelmää seuraavasti:

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vtr.työnnä takaisin(5.5);
kelluafl=vtr[4];
kustannus<<fl<< '' n'';

Lähtö on 5,5.

työnnä takaisin(rv): -nähdä myöhemmin.

pop_back ()

Poistaa viimeisen elementin palauttamatta sitä. Vektorin kokoa pienennetään yhdellä. Seuraava koodi havainnollistaa tätä:

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vtr.pop_back();
kelluas=vtr.koko();
kustannus<<s<< '' n'';

Lähtö on 3.

a. vaihto (b)

Kaksi vektoria voidaan vaihtaa, kuten seuraavassa koodisegmentissä on esitetty:

vektori<kellua>vtr1{1.1, 2.2, 3.3, 4.4};
vektori<kellua>vtr2{10, kaksikymmentä};
vtr1.vaihtaa(vtr2);
kustannus<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<''
''
<<vtr1[2] <<''<<vtr1[3] << '' n'';

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

Lähtö on:

vtr1: 10 kaksikymmentä 0 0
vtr2: 1.1 2.2 3.3 4.4

Huomaa, että vektorin pituutta lisätään tarvittaessa. Myös arvot, joilla ei ollut korvauksia, korvataan jollakin oletusarvolla.

asia selvä()

Poistaa kaikki elementit vektorista, kuten seuraava koodisegmentti havainnollistaa:

vektori<kellua>vtr{1.1, 2.2, 3.3, 4.4};
vtr.asia selvä();
kustannus<<vtr.koko() << '' n'';

Lähtö on 0.

Tasa -arvo- ja suhdeoperaattorit vektoreille

== operaattori

Palauttaa arvon 1 tosi, jos molemmat vektorit ovat samankokoisia ja vastaavat elementit ovat yhtä suuret; muussa tapauksessa palauttaa arvon 0 epätosi. Esimerkiksi:

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

Lähtö on 0.

The! = Käyttäjä

Palauttaa arvon 1 tosi, jos kahdella vektorilla ei ole samaa kokoa ja/tai vastaavat elementit eivät ole yhtä suuret; muussa tapauksessa palauttaa arvon 0 epätosi. Esimerkiksi:

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

Lähtö on 1.

The

Palauttaa arvon 1 tosi, jos ensimmäinen vektori on toisen vektorin alijoukko, jossa kahden saman osan elementit ovat samat ja samassa järjestyksessä. Jos molemmat vektorit ovat samankokoisia ja liikkuvat vasemmalta oikealle ja ensimmäisessä vektorissa on elementti, joka on pienempi kuin vastaavan elementin toisessa vektorissa, 1 palautetaan silti. Muussa tapauksessa arvo 0 palautetaan. Esimerkiksi:

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

Lähtö on 1.

> Käyttäjä

Palauttaa! (U

The<= Operator

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

> = Käyttäjä

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

Johtopäätös

Vektori on esimerkki sekvenssisäiliöstä. Vektori on parempi muoto tavallisesta taulukosta ja se syntyy luokasta. Vektoreissa on menetelmiä, jotka on luokiteltu seuraaviin: rakenne ja osoitus, kapasiteetti, elementtien käyttöoikeus, datan käyttö, iteraattorit, muokkaajat ja numeeriset ylikuormitetut operaattorit.

On olemassa myös muita sekvenssisäilöjä, joita kutsutaan luetteloksi, eteenpäin_listaksi ja matriisiksi. Jos tehtävään liittyy usein lisäyksiä ja poistoja sekvenssin keskelle, on käytettävä luetteloa tai eteenpäin_listaa. Jos tehtävä sisältää usein lisäyksiä ja poistoja sarjan alussa tai lopussa, on käytettävä dekkiä. Ja niin, vektoreita tulisi käyttää vain silloin, kun tällaiset toiminnot eivät ole tärkeitä.