30 Esimerkkejä C++-vektoreista

C++:ssa Vector on yksiulotteinen tietorakenne, joka kasvaa dynaamisesti tarpeen mukaan. Tietojen organisointi (lisäys/muokkaus/poisto) voidaan tehdä tehokkaasti tässä tietorakenteessa. Sen sovelluksia ovat seuraavat:

Matemaattisten vektorien edustaminen tieteellisissä ja teknisissä sovelluksissa
Tällä tietorakenteella voidaan toteuttaa jonoja, pinoja jne.

Suurin osa tähän tietorakenteeseen liittyvistä yleisistä CRUD-operaatioista ja toiminnoista käsitellään skenaariossa yksityiskohtaisesti syntaksin ja koodinpätkien kanssa.

Sisällön aihe:

Lisää elementti vektoriin
Lisää useita elementtejä vektoriin
Käytä elementtejä vektorista
Päivitä elementti vektorissa
Poista tietty elementti vektorista
Poista kaikki elementit vektorista
Vektorien liitto
Vektorien leikkauspiste
Tarkista, onko vektori tyhjä vai ei
Kulje vektorin läpi Const_Iteratorilla
Kulje vektorin läpi Reverse_Iteratorilla
Työnnä elementit vektoriin
Pop elementit vektorista
Vaihda vektorit
Hae ensimmäinen elementti vektorista
Hae viimeinen elementti vektorista
Määritä vektorille uusia arvoja
Laajenna vektoria käyttämällä Emplace()
Laajenna vektoria käyttämällä Emplace_Back()
Vektorin enimmäiselementti
Vektorin vähimmäiselementti
Vektorin elementtien summa
Kahden vektorin elementtiviisas kertominen
Kahden vektorin pistetulo
Muunna joukko vektoriksi
Poista päällekkäiset elementit
Muunna vektori joukoksi
Poista tyhjät merkkijonot
Kirjoita vektori tekstitiedostoon
Luo vektori tekstitiedostosta

Lisää elementti vektoriin

The std::vektori::lisää() -toimintoa C++ STL:ssä käytetään elementtien lisäämiseen määritettyyn kohtaan.

Syntaksi:

vektori. lisää ( asema, elementti ) ;

Hyödynnetään tätä toimintoa ja välitetään ensimmäinen paikka parametriksi, joka määrittää paikan, johon elementti on lisättävä, ja annetaan elementti toiseksi parametriksi.

Aloitusfunktiota () voidaan käyttää tässä palauttamaan iteraattori, joka osoittaa syötevektorin ensimmäiseen elementtiin. Kun lisäät sijainnin tähän toimintoon, elementti lisätään kyseiseen kohtaan.

Luodaan 'opiskelijoiden_nimet'-vektori, jonka tyyppi on string, ja lisätään kaksi merkkijonoa ensimmäiseen ja toiseen paikkaan peräkkäin insert()-funktiolla.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Vektorin alustus - opiskelijan_nimet

vektori < merkkijono > opiskelijoiden_nimet ;

cout << 'Olemassa oleva vektori: \n ' ;

varten ( auto i : opiskelijoiden_nimet ) cout << i << endl ;

// Lisää 'Sravan Kumar' ensimmäiseen kohtaan

opiskelijoiden_nimet. lisää ( opiskelijoiden_nimet. alkaa ( ) + 0 , 'Shravan Kumar' ) ;

// Lisää 'Sravan Kumar' toiseen paikkaan

opiskelijoiden_nimet. lisää ( opiskelijoiden_nimet. alkaa ( ) + 1 , 'Lalitha' ) ;

cout << 'Lopullinen vektori: \n ' ;

varten ( auto j : opiskelijoiden_nimet ) cout << j << endl ;

}

Lähtö:

Aiemmin opiskelijan_nimet-vektori oli tyhjä. Lisäyksen jälkeen vektorissa on kaksi elementtiä.

Lisää useita elementtejä vektoriin

Käytämme tässä skenaariossa samaa funktiota, joka on std::vector::insert(). Mutta meidän on välitettävä ylimääräiset/eri parametrit samalle funktiolle lisätäksesi useita elementtejä vektoriin.

Skenaario 1: Yhden elementin lisääminen useita kertoja

Tässä skenaariossa lisäämme saman elementin useita kertoja.

Syntaksi:

vektori. lisää ( sijainti, koko, elementti ) ;

Tätä varten meidän on välitettävä koko toisena parametrina insert()-funktiolle. Tälle funktiolle välitettävien parametrien kokonaismäärä on kolme.

Tässä:

Sijaintiparametri määrittää lisättävän elementin sijainnin. Jos koko on suurempi kuin 1, aloituspaikkaindeksi on sijainti.
Koko-parametri määrittää, kuinka monta kertaa elementti tulee lisätä.
Elementtiparametri vie elementin lisättäväksi vektoriin.

Harkitse 'opiskelijoiden_nimet' -vektoria, jossa on kaksi merkkijonoa. Aseta 'Lavanya' -kielet viisi kertaa toiseen kohtaan.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Vektorin alustus - opiskelijan_nimet

vektori < merkkijono > opiskelijoiden_nimet { 'Shravan Kumar' , 'Lalitha' } ;

cout << 'Olemassa oleva vektori: \n ' ;

varten ( auto i : opiskelijoiden_nimet ) cout << i << endl ;

// Lisää 'Lavanya' toiseen kohtaan 5 kertaa

opiskelijoiden_nimet. lisää ( opiskelijoiden_nimet. alkaa ( ) + 1 , 5 , 'Lavanya' ) ;

cout << ' \n Lopullinen vektori: \n ' ;

varten ( auto j : opiskelijoiden_nimet ) cout << j << endl ;

}

Lähtö:

Olemassa olevassa vektorissa 'Sravan Kumar' on ensimmäisellä paikalla ja 'Lalitha' on toisella paikalla. Lisättyään 'Lavanya' viisi kertaa (toisesta paikasta kuudenteen), 'Lalitha' siirtyi seitsemänneksi (viimeiseksi).

Skenaario 2: Useiden elementtien lisääminen

Tässä skenaariossa lisäämme eri elementit kerrallaan toisesta vektorista. Käytämme myös tässä samaa toimintoa, mutta syntaksi ja parametrit muuttuvat.

Syntaksi:

vektori. lisää ( sijainti, ensimmäinen_iteraattori, toinen_iteraattori ) ;

Tätä varten meidän on välitettävä koko toisena parametrina insert()-funktiolle. Tälle funktiolle välitettävien parametrien kokonaismäärä on kolme.

Tässä:

Sijaintiparametri määrittää lisättävän elementin sijainnin.
'first_iterator' määrittää aloituspaikan, josta elementit lisätään (periaatteessa begin()-funktiolla palautetaan iteraattori, joka osoittaa ensimmäiseen säiliössä olevaan elementtiin).
'Second_iterator' määrittää lopetuskohdan, johon asti elementit lisätään (periaatteessa end()-funktiolla palautetaan iteraattori, joka osoittaa viimeisen pisteen viereen, joka on säiliössä).

Luo kaksi kokonaislukutyyppistä vektoria, 'merkit1' ja 'merkit2'. Lisää kaikki elementit, jotka ovat 'marks2'-vektorissa 'marks1'-vektorin ensimmäiseen paikkaan.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Vektorin alustaminen - marks1

vektori < int > merkit 1 { 100 , 89 , 90 , 78 , 98 } ;

cout << 'Ensimmäinen vektori: \n ' ;

varten ( auto i : merkit 1 ) cout << i << endl ;

// Vektorin alustaminen - marks2

vektori < int > merkit 2 { 56 , Neljä viisi , 65 } ;

cout << 'Toinen vektori: \n ' ;

varten ( auto j : merkit 2 ) cout << j << endl ;

merkit 1. lisää ( alkaa ( merkit 1 ) , alkaa ( merkit 2 ) , loppu ( merkit 2 ) ) ;

// Lopullinen vektori

cout << 'Ensimmäinen viimeinen vektori: \n ' ;

varten ( auto x : merkit 1 )

cout << x << ' ' ;

}

Lähtö:

Ensimmäisessä vektorissa (merkit1) on viisi elementtiä ja toisessa vektorissa (merkit2) kolme elementtiä. Välitimme alkamis (marks1), begin (marks2), end(marks2) -parametrit 'insert'-funktiolle siten, että kaikki toisessa vektorissa olevat elementit iteroidaan ja lisätään ensimmäiseen vektoriin alussa. Joten ensimmäinen vektori sisältää kahdeksan elementtiä.

Käytä elementtejä vektorista

1. Käytä []-toimintoa

Joissakin skenaarioissa saatat joutua palauttamaan vektorista vain tietyt elementit. Kaikkia elementtejä ei tarvitse palauttaa. Joten jos haluat palauttaa vain tietyt indeksiin perustuvat elementit, käytetään indeksioperaattoria ja at()-funktioita.

Syntaksi:

vektori [ index_position ]

C++:ssa indeksointi alkaa 0:sta mille tahansa tietorakenteelle. Jos elementtiä ei ole olemassa, se palaa tyhjänä (Ei virhettä tai varoitus annetaan).

Harkitse 'tuotteiden' vektoria, jossa on viisi kohdetta. Pääset kaikkiin elementteihin yksitellen käyttämällä indeksipaikkaa.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - tuotteet, joissa on 5 merkkijonoa

vektori < merkkijono > Tuotteet { 'saippua' , 'shampoo' , 'öljy' , 'hedelmät' , 'vihannekset' } ;

//Elementtien käyttö tuotteista

cout << 'Ensimmäinen elementti:' << Tuotteet [ 0 ] << endl ;

cout << 'Toinen elementti:' << Tuotteet [ 1 ] << endl ;

cout << 'Kolmas elementti:' << Tuotteet [ 2 ] << endl ;

cout << 'Neljäs elementti:' << Tuotteet [ 3 ] << endl ;

cout << 'Viides elementti:' << Tuotteet [ 4 ] << endl ;

// Yritä käyttää 9. elementtiä

cout << 'Yhdeksäs elementti:' << Tuotteet [ 8 ] << endl ;

}

Lähtö:

Indeksissä 8 ei ole elementtiä. Joten palautetaan tyhjä.

2. At()-funktion käyttäminen

At() on jäsenfunktio, joka on samanlainen kuin edellinen käyttötapaus, mutta se palauttaa 'std::out_of_range' -poikkeuksen, kun sille tarjotaan indeksi alueen ulkopuolella.

Syntaksi:

vektori. klo ( index_position )

Meidän on välitettävä indeksisijainti tälle funktiolle.

Harkitse 'tuotteiden' vektoria, jossa on viisi kohdetta. Siirry kaikkiin elementteihin yksitellen käyttämällä indeksipaikkaa ja yritä päästä käsiksi elementtiin, joka on 9. sijainnissa.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - tuotteet, joissa on 5 merkkijonoa

vektori < merkkijono > Tuotteet { 'saippua' , 'shampoo' , 'öljy' , 'hedelmät' , 'vihannekset' } ;

//Elementtien käyttö tuotteista

cout << 'Ensimmäinen elementti:' << Tuotteet. klo ( 0 ) << endl ;

cout << 'Toinen elementti:' << Tuotteet. klo ( 1 ) << endl ;

cout << 'Kolmas elementti:' << Tuotteet. klo ( 2 ) << endl ;

cout << 'Neljäs elementti:' << Tuotteet. klo ( 3 ) << endl ;

cout << 'Viides elementti:' << Tuotteet. klo ( 4 ) << endl ;

//Elementtien käyttäminen, jotka eivät ole vektorissa

cout << 'Yhdeksäs elementti:' << Tuotteet. klo ( 8 ) << endl ;

}

Lähtö:

Virhe käytettäessä 9. elementtiä:

terminate kutsutaan esiintymän heittämisen jälkeen 'std::out_of_range'

mitä ( ) : vektori :: _M_alue_check : __n ( mikä on 8 ) >= Tämä - > koko ( ) ( mikä on 5 )

Päivitä elementti vektorissa

1. Käytä []-toimintoa

Käyttämällä indeksipaikkaa voimme päivittää elementin vektorissa. []-operaattori ottaa päivitettävän elementin indeksipaikan. Uusi elementti määrätään tälle operaattorille.

Syntaksi:

Vektori [ index_position ] = Elementti

Harkitse 'opiskelijamerkit' -vektoria, jossa on viisi arvoa. Päivitä indeksien 1 ja 3 elementit.

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - opiskelijamerkit

vektori < int > opiskelija_merkit { 98 , 78 , 90 , 67 , 89 } ;

cout << 'Olemassa olevat merkit:' << endl ;

varten ( int itr : opiskelija_merkit )

cout << itr << endl ;

// Päivitä elementti indeksissä 3 arvolla 100

opiskelija_merkit [ 3 ] = 100 ;

// Päivitä elementti indeksissä 1 arvolla 60

opiskelija_merkit [ 1 ] = 60 ;

cout << 'Lopulliset pisteet:' << endl ;

varten ( int itr : opiskelija_merkit )

cout << itr << endl ;

}

Lähtö:

Näemme, että viimeinen vektori pitää päivityselementit indekseissä 1 ja 3.

2. At()-funktion käyttäminen

Kuten indeksioperaattori, at() on periaatteessa jäsenfunktio, joka päivittää arvon iteraattorin indeksin perusteella. Jos tässä funktiossa määritettyä indeksiä ei ole olemassa, 'std::out_of_range' -poikkeus heitetään.

vektori. klo ( index_position ) = Elementti

Harkitse 'tuotteiden' vektoria, jossa on viisi kohdetta. Päivitä kaikki vektorissa olevat elementit muilla elementeillä.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - tuotteet, joissa on 5 merkkijonoa

vektori < merkkijono > Tuotteet { 'saippua' , 'shampoo' , 'öljy' , 'hedelmät' , 'vihannekset' } ;

cout << 'Olemassa olevat tuotteet:' << endl ;

varten ( merkkijono itr : Tuotteet )

cout << itr << endl ;

//Päivitetään kaikkia merkkijonoja

Tuotteet. klo ( 0 ) = 'Kakku' ;

Tuotteet. klo ( 1 ) = 'Suklaa' ;

Tuotteet. klo ( 2 ) = 'Hedelmät' ;

Tuotteet. klo ( 3 ) = 'sipulia' ;

Tuotteet. klo ( 4 ) = 'Virvoitusjuomat' ;

cout << ' \n Lopputuotteet: ' << endl ;

varten ( merkkijono itr : Tuotteet )

cout << itr << endl ;

}

Lähtö:

Poista tietty elementti vektorista

C++:ssa std::vektori::erase() -funktiota käytetään poistamaan tietty elementti/elementtialue vektorista. Elementit poistetaan iteraattoripaikkojen perusteella.

Syntaksi:

vektori. pyyhkiä ( iteraattorin sijainti )

Katsotaanpa syntaksi tietyn elementin poistamiseksi vektorista. Voimme käyttää start()- tai end()-funktioita saadakseen poistettavan vektorin elementin sijainnin.

Harkitse 'tuotteiden' vektoria, jossa on viisi kohdetta.

Poista kolmas elementti määrittämällä begin()-iteraattori. Begin() osoittaa vektorin ensimmäiseen elementtiin. Jos tähän funktioon lisätään kaksi, se osoittaa kolmanteen elementtiin.
Poista viimeinen elementti määrittämällä end()-iteraattori. End() osoittaa vektorin viimeiseen elementtiin.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - tuotteet, joissa on 5 merkkijonoa

vektori < merkkijono > Tuotteet { 'saippua' , 'shampoo' , 'öljy' , 'hedelmät' , 'vihannekset' } ;

cout << 'Olemassa olevat tuotteet:' << endl ;

varten ( merkkijono itr : Tuotteet )

cout << itr << endl ;

// Poista kolmas elementti

Tuotteet. pyyhkiä ( Tuotteet. alkaa ( ) + 2 ) ;

cout << ' \n Kolmannen elementin poistamisen jälkeen: \n ' ;

varten ( merkkijono itr : Tuotteet )

cout << itr << endl ;

// Poista viimeinen elementti

Tuotteet. pyyhkiä ( Tuotteet. loppu ( ) ) ;

cout << ' \n Viimeisen elementin poistamisen jälkeen: \n ' ;

varten ( merkkijono itr : Tuotteet )

cout << itr << endl ;

}

Lähtö:

Nyt 'tuotevektorissa' on vain kolme elementtiä ('saippua', 'shampoo', 'hedelmät').

Poista kaikki elementit vektorista

Skenaario 1: Poista elementtialue vektorista

Käytämme std::vector::erase()-funktiota useiden elementtien poistamiseen alueella.

Syntaksi:

vektori. pyyhkiä ( iteraattori ensin, iteraattori viimeisenä )

Kahta iteraattoria (begin() osoittaa ensimmäiseen elementtiin ja end() osoittaa viimeiseen elementtiin) käytetään alueen määrittämiseen.

Harkitse 'tuote' -vektoria, jossa on viisi kohdetta, ja poista kaikki elementit toisesta paikasta. Tämän saavuttamiseksi ensimmäinen iteraattori on begin (products)+1, joka osoittaa toiseen elementtiin ja toinen iteraattori on end (products).

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - tuotteet, joissa on 5 merkkijonoa

vektori < merkkijono > Tuotteet { 'saippua' , 'shampoo' , 'öljy' , 'hedelmät' , 'vihannekset' } ;

cout << 'Olemassa olevat tuotteet:' << endl ;

varten ( merkkijono itr : Tuotteet )

cout << itr << endl ;

// Poista kaikki elementit toisesta paikasta

Tuotteet. pyyhkiä ( alkaa ( Tuotteet ) + 1 , loppu ( Tuotteet ) ) ;

cout << ' \n Lopputuotteet: \n ' ;

varten ( merkkijono itr : Tuotteet )

cout << itr << endl ;

}

Lähtö:

Nyt 'tuotteet'-vektorissa on vain yksi elementti ('saippua').

Skenaario 2: Poista kaikki elementit vektorista

Käytetään std::vektori::clear() toiminto poistaa kaikki elementit vektorista.

Syntaksi:

vektori. asia selvä ( )

Tälle funktiolle ei välitetä parametreja.

Harkitse samaa vektoria, jota käytettiin ensimmäisessä skenaariossa, ja poista kaikki elementit clear()-funktiolla.

Lähtö:

Voimme nähdä, että 'tuotteet'-vektorissa ei ole elementtejä.

Vektorien liitto

On mahdollista suorittaa UNION-toiminto vektoreille käyttämällä std::set_union()-funktiota. Unioni palauttaa ainutlaatuiset elementit vektoreista jättämällä huomioimatta päällekkäiset elementit. Meidän on siirrettävä molemmat iteraattorit tälle funktiolle. Tämän lisäksi on läpäistävä tulositeraattori, joka tallentaa molempien iteraattorien palauttaman tuloksen.

Syntaksi:

set_union ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator res ) ;

Tässä:

'First1' osoittaa ensimmäisen iteraattorin (vektorin) ensimmäiseen elementtiin.
'Last1' osoittaa ensimmäisen iteraattorin (vektorin) viimeiseen elementtiin.
'First2' osoittaa toisen iteraattorin (vektorin) ensimmäiseen elementtiin.
'Last2' osoittaa toisen iteraattorin (vektorin) viimeiseen elementtiin.

Luo kaksi vektoria - 'subjects1' ja 'subjects2' - tyyppiä kokonaisluku.

Lajittele kaksi vektoria käyttämällä sort()-funktiota ohittamalla iteraattorit.
Luo tulosvektori (iteraattori).
Etsi näiden kahden vektorin liitto std::set_union()-funktiolla. Käytä begin():tä ensimmäisenä iteraattorina ja end():tä viimeisenä iteraattorina.
Iteroi tulosvektori näyttääksesi elementit, jotka funktio palauttaa.

#include

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - marks1

vektori < int > merkit 1 = { 100 , 90 , 80 , 70 , 60 } ;

// Luo vektori - marks2

vektori < int > merkit 2 = { 80 , 90 , 60 , 70 , 100 } ;

// Lajittele molemmat vektorit

järjestellä ( merkit 1. alkaa ( ) , merkit1. loppu ( ) ) ;

järjestellä ( merkit 2. alkaa ( ) , merkit 2. loppu ( ) ) ;

vektori < int > lähtövektori ( merkit 1. koko ( ) + merkit 2. koko ( ) ) ;

vektori < int > :: iteraattori On ;

i = set_union ( merkit 1. alkaa ( ) , merkit1. loppu ( ) ,

merkit 2. alkaa ( ) ,merkit2. loppu ( ) ,

lähtövektori. alkaa ( ) ) ;

cout << ' \n marks1 U marks2: \n ' ;

varten ( s = lähtövektori. alkaa ( ) ; s ! = i ; ++ s )

cout << * s << ' ' << ' \n ' ;

}

Lähtö:

Molemmissa vektoreissa (subjektit1 ja subjektit2) on vain viisi ainutlaatuista elementtiä.

Vektorien leikkauspiste

Kahden vektorin leikkauspisteen löytäminen voi olla mahdollista std::set_intersection()-funktiolla. Leikkaus palauttaa elementit, jotka ovat molemmissa vektoreissa.

Syntaksi:

set_ristection ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator res ) ;

Set_union()-funktiolle välitetyt parametrit voidaan välittää myös tälle set_intersection()-funktiolle.

Luo kaksi vektoria - 'subjects1' ja 'subjects2' - tyyppiä kokonaisluku.

Lajittele kaksi vektoria käyttämällä sort()-funktiota ohittamalla iteraattorit.
Luo tulosvektori (iteraattori).
Etsi näiden kahden vektorin leikkauspiste std::set_intersection()-funktiolla. Käytä begin():tä ensimmäisenä iteraattorina ja end():tä viimeisenä iteraattorina.
Iteroi tulosvektori näyttääksesi elementit, jotka funktio palauttaa.

#include

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - marks1

vektori < int > merkit 1 = { 100 , 10 , 80 , 40 , 60 } ;

// Luo vektori - marks2

vektori < int > merkit 2 = { viisikymmentä , 90 , 60 , 10 , 100 } ;

// Lajittele molemmat vektorit

järjestellä ( merkit 1. alkaa ( ) , merkit1. loppu ( ) ) ;

järjestellä ( merkit 2. alkaa ( ) , merkit 2. loppu ( ) ) ;

vektori < int > lähtövektori ( merkit 1. koko ( ) + merkit 2. koko ( ) ) ;

vektori < int > :: iteraattori On ;

i = set_ristection ( merkit 1. alkaa ( ) , merkit1. loppu ( ) ,

merkit 2. alkaa ( ) ,merkit2. loppu ( ) ,

lähtövektori. alkaa ( ) ) ;

cout << ' \n marks1 ∩ marks2: \n ' ;

varten ( s = lähtövektori. alkaa ( ) ; s ! = i ; ++ s )

cout << * s << ' ' << ' \n ' ;

}

Lähtö:

Molemmissa vektoreissa (subjektit1 ja subjektit2) on vain kolme elementtiä.

Tarkista, onko vektori tyhjä vai ei

Ennen vektoreiden käsittelyä on tärkeää tarkistaa, onko vektori tyhjä vai ei. Ohjelmistoprojekteissa on myös hyvä käytäntö tarkistaa, onko vektori tyhjä vai ei, ennen kuin teet operaatioita, kuten CRUD-toimintoja jne.

1. Std::vector::empty()

Tämä funktio palauttaa arvon 1, jos vektori on tyhjä (ei sisällä elementtiä). Muussa tapauksessa palautetaan 0. Tälle funktiolle ei välitetä parametreja.

2. Käyttämällä Vakio::vektori::koko()

Funktio std::vector::size() palauttaa kokonaisluvun, joka edustaa vektorissa olevien elementtien kokonaismäärää.

Luo kaksi vektoria – 'kollegio1' ja 'oppilaitos2'. 'College1' sisältää viisi elementtiä ja 'kollegio2' on tyhjä. Käytä molempia funktioita molemmissa vektoreissa ja tarkista tulos.

#include

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - college1

vektori < merkkijono > yliopisto 1 = { 'opisto-A' , 'yliopisto-B' , 'opisto-C' , 'oppilaitos-D' , 'opisto-E' } ;

// Luo vektori - college2

vektori < merkkijono > yliopisto 2 ;

// tyhjä()

cout << yliopisto 1. tyhjä ( ) << endl ;

cout << yliopisto 2. tyhjä ( ) << endl ;

// koko()

cout << yliopisto 1. koko ( ) << endl ;

cout << yliopisto 2. koko ( ) << endl ;

}

Lähtö:

Tyhjä()-funktio palauttaa 0:n 'kollegiolle1' ja 1:n 'kollegio2:lle'. Koko()-funktio palauttaa viisi arvolle 'kollegio1' ja 0 arvolle 'kollegio2'.

Kulje vektorin läpi Const_Iteratorin avulla

Kun työskentelet C++-säilöillä, kuten joukoilla, vektoreilla jne., on mahdollista iteroida kaikkia säilössä olevia elementtejä muokkaamatta niitä. The const_iterator on yksi iteraattoreista, jotka saavuttavat tämän skenaarion. cbegin() (osoittaa vektorin ensimmäiseen elementtiin) ja cend() (osoittaa vektorin viimeiseen elementtiin) ovat kunkin säilön kaksi funktiota, joita käytetään palauttamaan vakioiteraattorin alkuun ja loppuun. kontti. Vektoria iteroitaessa voimme hyödyntää näitä kahta funktiota.

Luodaan vektori nimeltä 'osastot', jossa on viisi merkkijonoa.
Ilmoita const_iterator – ctr tyyppiä .
Iteroi osastojen yli käyttämällä edellistä iteraattoria 'for'-silmukan avulla ja näytä se.

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - osastot

vektori < merkkijono > osastot = { 'Myynti' , 'Palvelu' ,

'HR' , 'SE' , 'muut' } ;

vektori < merkkijono > :: const_iterator ctr ;

// Iteroi osastojen yli käyttämällä const_iterator - ctr.

varten ( ctr = osastot. cbegin ( ) ; ctr ! = osastot. muutama ( ) ; ctr ++ ) {

cout << * ctr << endl ;

}

}

Lähtö:

Kulje vektorin läpi Reverse_Iteratorin avulla

The reverse_iterator on myös iteraattori, joka on samanlainen kuin const_iterator, mutta se palauttaa elementit käänteisesti. rbegin() (osoittaa vektorin viimeiseen elementtiin) ja rend() (osoittaa vektorin ensimmäiseen elementtiin) ovat kunkin säilön kaksi funktiota, joita käytetään palauttamaan vakioiteraattorin loppuun ja alkuun. kontti.

Luodaan vektori nimeltä 'osastot', jossa on viisi merkkijonoa.
Ilmoita reverse_iterator – rtr, jonka tyyppi on .
Iteroi osastojen yli käyttämällä edellistä iteraattoria 'for'-silmukan avulla ja näytä se.

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - osastot

vektori < merkkijono > osastot = { 'Myynti' , 'Palvelu' ,

'HR' , 'SE' , 'muut' } ;

vektori < merkkijono > :: reverse_iterator rtr ;

// Iteroi osastojen yli käyttämällä reverse_iterator - rtr.

varten ( rtr = osastot. rbegin ( ) ; rtr ! = osastot. tekee ( ) ; rtr ++ ) {

cout << * rtr << endl ;

}

}

Lähtö:

Työnnä elementit vektoriin

Elementtien työntäminen tai liittäminen vektoriin on yksisuuntainen lisäys, joka voidaan tehdä käyttämällä vektori::push_back() toiminto.

Syntaksi:

vektori. työnnä takaisin ( elementti )

Se vaatii elementin, joka työnnetään vektoriin parametrina.

Luodaan tyhjä vektori nimeltä 'osastot', jossa on viisi merkkijonoa ja työnnetään kaksi merkkijonoa peräkkäin push_back()-funktiolla.

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Alusta vektori - osastot

vektori < merkkijono > osastot ;

cout << 'Varsinaiset osastot:' << endl ;

varten ( auto itr = osastot. alkaa ( ) ; itr ! = osastot. loppu ( ) ; ++ itr )

cout << * itr << endl ;

// Paina 'Myynti'

osastot. työnnä takaisin ( 'Myynti' ) ;

// Työnnä'

osastot. työnnä takaisin ( 'SE' ) ;

cout << ' \n Loppuosastot:' << endl ;

varten ( auto itr = osastot. alkaa ( ) ; itr ! = osastot. loppu ( ) ; ++ itr )

cout << * itr << endl ;

}

Lähtö:

Ensin painamme 'myyntiä'. Sen jälkeen 'IT' työnnetään vektoriin. Nyt 'osastojen' vektorissa on kaksi elementtiä.

Pop elementit vektorista

Jos haluat poistaa viimeisen vektorissa olevan kohteen, käyttämällä vektori::pop_back() toiminto on paras tapa. Se poistaa vektorissa viimeisen elementin.

Syntaksi:

vektori. pop_back ( )

Tähän toimintoon ei tarvita parametreja. Se näyttää määrittelemättömän käyttäytymisen, jos yritämme poistaa viimeisen elementin tyhjästä vektorista.

Luodaan tyhjä vektori nimeltä 'osastot' viidellä merkkijonolla ja poista viimeinen elementti käyttämällä edellistä funktiota. Näytä vektori molemmissa tapauksissa.

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Alusta vektori - osastot

vektori < merkkijono > osastot = { 'Myynti' , 'SE' , 'Palvelu' , 'Markkinointi' , 'HR' } ;

cout << 'Varsinaiset osastot:' << endl ;

varten ( auto itr = osastot. alkaa ( ) ; itr ! = osastot. loppu ( ) ; ++ itr )

cout << * itr << endl ;

// Poista viimeinen elementti

osastot. pop_back ( ) ;

cout << ' \n Loppuosastot:' << endl ;

varten ( auto itr = osastot. alkaa ( ) ; itr ! = osastot. loppu ( ) ; ++ itr )

cout << * itr << endl ;

}

Lähtö:

'HR' on viimeinen elementti, joka on 'osastot'-vektorissa. Joten se poistetaan vektorista ja lopullinen vektori sisältää 'myynti', 'IT', 'palvelu' ja 'markkinointi'.

Vaihda vektorit

The vektori::swap() funktiota C++ STL:ssä käytetään vaihtamaan kaikki kahdessa vektorissa olevat elementit.

Syntaksi:

ensimmäinen_vektori. vaihtaa ( toinen_vektori )

Se ei ota huomioon vektorien kokoa, mutta vektorien tulee olla samaa tyyppiä (virhe heitetään, jos vektorityypit ovat erilaisia).

Luodaan kaksi erikokoista merkkijonotyyppistä vektoria – 'hedelmät' ja 'vihannekset'. Vaihda jokainen niistä ja näytä vektorit molemmissa tapauksissa.

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Alusta vektori - hedelmät

vektori < merkkijono > hedelmiä = { 'Omena' , 'Mango' } ;

cout << 'Todelliset hedelmät:' << endl ;

varten ( auto itr = hedelmiä. alkaa ( ) ; itr ! = hedelmiä. loppu ( ) ; ++ itr )

cout << * itr << endl ;

// Alusta vektori - vihannekset

vektori < merkkijono > vihannekset = { 'Peruna' , 'Tomaatti' , 'Brinjal' } ;

cout << ' \n Varsinaiset vihannekset:' << endl ;

varten ( auto itr = vihannekset. alkaa ( ) ; itr ! = vihannekset. loppu ( ) ; ++ itr )

cout << * itr << endl ;

// Vaihda elementit molemmissa vektoreissa

hedelmiä. vaihtaa ( vihannekset ) ;

cout << ' \n Hedelmät vaihdon jälkeen:' << endl ;

varten ( auto itr = hedelmiä. alkaa ( ) ; itr ! = hedelmiä. loppu ( ) ; ++ itr )

cout << * itr << endl ;

cout << ' \n Vihannekset vaihdon jälkeen:' << endl ;

varten ( auto itr = vihannekset. alkaa ( ) ; itr ! = vihannekset. loppu ( ) ; ++ itr )

cout << * itr << endl ;

}

Lähtö:

Aikaisemmin 'hedelmä'-vektori sisältää kaksi elementtiä ja 'vihannekset' -vektori sisältää kolme elementtiä. Vaihdon jälkeen 'hedelmä'-vektori sisältää kolme elementtiä ja 'vihannekset' -vektori sisältää kaksi elementtiä.

Hae ensimmäinen elementti vektorista

Joissakin tapauksissa vaatimus on palauttaa vain ensimmäinen elementti vektorista. Vektori::front()-funktio C++ STL:ssä hakee vain ensimmäisen elementin vektorista.

Syntaksi:

vektori. edessä ( )

Tämä toiminto ei ota mitään parametreja. Jos vektori on tyhjä, annetaan virhe.

Luodaan kaksi merkkijonotyyppistä vektoria – 'hedelmät' ja 'vihannekset' ja yritetään hakea ensimmäinen elementti erikseen kahdesta vektorista.

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - hedelmät 2 elementillä

vektori < merkkijono > hedelmiä = { 'Omena' , 'Mango' } ;

// Palauta ensimmäinen elementti

cout << hedelmiä. edessä ( ) << endl ;

// Alusta vektori - vihannekset

vektori < merkkijono > vihannekset ;

// Yritä palauttaa ensimmäinen elementti

cout << vihannekset. edessä ( ) ;

}

Lähtö:

'Omena' on ensimmäinen elementti, joka on läsnä 'hedelmien' vektorissa. Eli palautetaan. Mutta virhe heitetään, kun yritämme noutaa ensimmäisen elementin 'vihanneksista' -vektorista, koska se on tyhjä.

Hae viimeinen elementti vektorista

Vektori::end()-funktio C++ STL:ssä hakee vain viimeisen elementin vektorista.

Syntaksi:

vektori. takaisin ( )

Tämä toiminto ei ota mitään parametreja. Jos vektori on tyhjä, annetaan virhe.

Luodaan kaksi merkkijonotyyppistä vektoria – 'hedelmät' ja 'vihannekset' ja yritetään hakea viimeinen elementti erikseen kahdesta vektorista.

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - hedelmät 2 elementillä

vektori < merkkijono > hedelmiä = { 'Omena' , 'Mango' } ;

// Hae viimeinen elementti

cout << hedelmiä. takaisin ( ) << endl ;

// Alusta vektori - vihannekset

vektori < merkkijono > vihannekset ;

// Yritä hakea viimeinen elementti

cout << vihannekset. takaisin ( ) ;

}

Lähtö:

'Mango' on viimeinen elementti, joka on läsnä 'hedelmä'-vektorissa. Eli palautetaan. Mutta virhe heitetään, kun yritämme hakea viimeistä elementtiä 'vihannesvektorista', koska se on tyhjä.

Määritä vektorille uusia arvoja

Joissakin tilanteissa, jos haluat päivittää kaikki arvot uudella arvolla tai luoda vektorin samoilla arvoilla, vektorin::assign()-funktion käyttö on paras tapa. Käyttämällä tätä toimintoa voimme:

Luo vektori, jossa on kaikki samanlaiset elementit
Muokkaa olemassa olevaa vektoria samalla elementillä

Syntaksi:

vektori. antaa ( koko, arvo )

Tämä toiminto vaatii kaksi parametria.

Tässä:

Koko määrittää määritettävien elementtien määrän.
Arvo määrittää määritettävän elementin.

Luodaan vektori nimeltä 'marks1' viidellä arvolla ja päivitetään tämä vektori neljällä elementillä siten, että päivitetyn vektorin kaikki elementit ovat yhtä suuret kuin 20.

#include

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - marks1

vektori < int > merkit 1 = { 100 , 90 , 80 , 70 , 60 } ;

cout << 'Todellinen vektori:' << endl ;

varten ( int i = 0 ; i < merkit 1. koko ( ) ; i ++ )

cout << merkit 1 [ i ] << endl ;

merkit 1. antaa ( 4 , kaksikymmentä ) ;

cout << ' \n Päivitetty vektori:' << endl ;

varten ( int i = 0 ; i < merkit 1. koko ( ) ; i ++ )

cout << merkit 1 [ i ] << endl ;

}

Lähtö:

Aiemmin vektorissa on viisi eri elementtiä. Nyt siinä on vain neljä elementtiä ja kaikki ovat yhtä suuria kuin 20.

Laajenna vektoria käyttämällä Emplace()

Tiedämme jo, että uusia elementtejä lisätään dynaamisesti mihin tahansa kohtaan vektorissa. Se on mahdollista käyttämällä vektori::emplace()-funktiota. Katsotaanpa nopeasti tämän funktion hyväksymiä syntaksia ja parametreja.

Syntaksi:

vektori. sijainti ( const_iterator sijainti, elementti )

Tälle funktiolle välitetään kaksi pakollista parametria.

Tässä:

Ensimmäinen parametri ottaa paikan, jotta voimme lisätä elementin mihin tahansa kohtaan. Voimme saada sijainnin käyttämällä begin() tai end() iteraattorifunktiota.
Toinen parametri on vektoriin lisättävä elementti.

Harkitse 'kemikaalien' vektoria, jossa on kaksi elementtiä.

Lisää 'Mangaani' ensimmäiseen kohtaan - aloita (kemikaalit)
Lisää 'Kupari' viimeiseen kohtaan - päähän (kemikaalit)
Lisää kolmanteen kohtaan 'Sulphur' - aloitus(kemikaalit)+2

#include

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - kemikaalit

vektori < merkkijono > kemikaalit = { 'Happi' , 'CO' } ;

cout << 'Todelliset kemikaalit:' << endl ;

varten ( int i = 0 ; i < kemikaalit. koko ( ) ; i ++ )

cout << kemikaalit [ i ] << endl ;

// Lisää elementti ensimmäiseen kohtaan

kemikaalit. sijainti ( alkaa ( kemikaalit ) , 'Mangaani' ) ;

// Lisää elementti viimeiseen kohtaan

kemikaalit. sijainti ( loppu ( kemikaalit ) , 'Kupari' ) ;

// Lisää elementti kolmanteen paikkaan

kemikaalit. sijainti ( alkaa ( kemikaalit ) + 2 , 'Rikki' ) ;

cout << ' \n Lopulliset kemikaalit:' << endl ;

varten ( int i = 0 ; i < kemikaalit. koko ( ) ; i ++ )

cout << kemikaalit [ i ] << endl ;

}

Lähtö:

Nyt lopullisessa vektorissa on viisi elementtiä (seuraavassa kuvakaappauksessa).

Laajenna vektoria käyttämällä Emplace_Back()

Elementti voidaan liittää (lisäämällä vektorin loppuun), joka voidaan tehdä käyttämällä vektori::emplace_back() toiminto.

Syntaksi:

vektori. emplace_back ( elementti )

Vektoriin liitettävä elementti on pakollista välittää parametrina.

Lisätään kaksi elementtiä peräkkäin käyttämällä emplace_back()-funktiota.

#include

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - kemikaalit

vektori < merkkijono > kemikaalit = { 'Happi' , 'CO' } ;

cout << 'Todelliset kemikaalit:' << endl ;

varten ( int i = 0 ; i < kemikaalit. koko ( ) ; i ++ )

cout << kemikaalit [ i ] << endl ;

// Lisää mangaani vektorin loppuun

kemikaalit. emplace_back ( 'Mangaani' ) ;

// Lisää mangaani vektorin loppuun

kemikaalit. emplace_back ( 'Kupari' ) ;

cout << ' \n Lopulliset kemikaalit:' << endl ;

varten ( int i = 0 ; i < kemikaalit. koko ( ) ; i ++ )

cout << kemikaalit [ i ] << endl ;

}

Lähtö:

Nyt viimeisessä vektorissa on neljä elementtiä, kun on lisätty 'mangaani' ja 'kupari'.

Vektorin enimmäiselementti

Luo vektori joistakin elementeistä.
Löytääksesi vektorissa olevan enimmäiselementin, käytä *max_element()-funktiota, joka hyväksyy kaksi iteraattoria argumenteiksi. Nämä kaksi parametria toimivat alueena ja maksimielementti palautetaan annetulla alueella. Aloituspaikka on begin() ja viimeinen sijainti on end().

* max_element ( ensimmäinen_indeksi, viimeinen_indeksi )

Tarkastellaan vektoria nimeltä 'item_costs', joka sisältää viisi kokonaislukutyyppiä ja palauttaa enimmäiselementin.

#sisällytä

#include

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - item_costs

vektori < int > item_costs = { 8900 , 5677 , 200 , 1000 , 2300 } ;

cout << 'Tuotteiden hinta: \n ' ;

varten ( int i = 0 ; i < item_costs. koko ( ) ; i ++ )

cout << item_costs [ i ] << endl ;

// Palauttaa maksimielementin yllä olevasta vektorista - item_costs

cout << ' \n Korkein hinta: ' << * max_element ( alkaa ( item_costs ) , loppu ( item_costs ) ) ;

}

Lähtö:

Tässä 8900 on maksimielementti kaikkien 'item_costs' -vektorissa olevien elementtien joukossa.

Vektorin vähimmäiselementti

Luo vektori joistakin elementeistä.
Löytääksesi vektorissa olevan vähimmäiselementin, käytä *min_element()-funktiota, joka hyväksyy kaksi iteraattoria argumenteiksi. Nämä kaksi parametria toimivat alueena ja minimielementti (pienempi kuin kaikki muut elementit) palautetaan annetulla alueella. Aloituspaikka on begin() ja viimeinen sijainti on end().

* min_element ( ensimmäinen_indeksi, viimeinen_indeksi )

Käytä samaa vektoria, joka on luotu löytääksesi maksimielementin ja etsi minimielementti käyttämällä *min_element()-funktiota.

#sisällytä

#include

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - item_costs

vektori < int > item_costs = { 8900 , 5677 , 200 , 1000 , 2300 } ;

cout << 'Tuotteiden hinta: \n ' ;

varten ( int i = 0 ; i < item_costs. koko ( ) ; i ++ )

cout << item_costs [ i ] << endl ;

// Palauta minimielementti yllä olevasta vektorista - item_costs

cout << ' \n Vähimmäiskustannukset: ' << * min_element ( alkaa ( item_costs ) , loppu ( item_costs ) ) ;

}

Lähtö:

Tässä 200 on vähimmäiselementti kaikkien 'item_costs' -vektorissa olevien elementtien joukossa.

Vektorin elementtien summa

Palauttaaksesi kaikkien vektorissa olevien elementtien summan, kerääntyä () toimintoa käytetään C++ STL:ssä. Se hyväksyy kolme parametria. Ensimmäinen parametri ottaa ensimmäisen indeksin, joka edustaa alueen aloituselementtiä (määritä begin()-iteraattori) ja toinen parametri ottaa viimeisen indeksin, joka edustaa alueen loppuelementtiä (määritä end()-iteraattori). Lopuksi meidän on välitettävä summan alkuarvo (tapauksessamme se on 0).

kerääntyä ( ensimmäinen_indeksi, viimeinen_indeksi, alkuarvo ) ;

Luo vektori nimeltä 'item_costs', jossa on viisi kokonaislukutyyppistä elementtiä ja laske summa.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - item_costs

vektori < int > item_costs = { 8900 , 5677 , 200 , 1000 , 2300 } ;

cout << 'Tuotteiden hinta: \n ' ;

varten ( int i = 0 ; i < item_costs. koko ( ) ; i ++ )

cout << item_costs [ i ] << endl ;

// Palauttaa kaikkien elementtien summan yllä olevassa vektorissa - item_costs

cout << ' \n Kokonaiskustannukset: ' << kerääntyä ( alkaa ( item_costs ) , loppu ( item_costs ) , 0 ) ;

}

Lähtö:

Summa 8900, 5677, 200, 1000, 2300 on 18077.

Kahden vektorin elementtiviisas kertominen

Luo kaksi vektoria, joiden tyyppi on numeerinen, ja kahden vektorin on oltava samankokoisia (ensimmäisessä vektorissa olevien elementtien kokonaismäärä = toisessa vektorissa olevien elementtien kokonaismäärä).
Ilmoita uusi vektori ja käytä silmukalle , suorita kertolasku kahdelle elementille kussakin iteraatiossa ja tallenna arvo luotuun vektoriin push_back()-funktiolla.

varten

(

int

;

koko

(

)

;

)

{

työnnä takaisin

(

[

]

[

]

)

;

}

Näytä resultanttivektorissa olevat elementit iteroimalla sitä.

Luo vektori nimeltä 'item_costs', jossa on viisi kokonaislukutyyppistä elementtiä ja laske summa.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo kaksi vektoria - tuotteet1 ja tuotteet2, joissa kummassakin on 5 elementtiä

vektori < int > tuotteet 1 = { 10 , kaksikymmentä , 30 , 40 , viisikymmentä } ;

vektori < int > tuotteet 2 = { viisikymmentä , 40 , 30 , 70 , 60 } ;

vektori < int > tulos_tuotteet ;

// Suorita elementtikohtainen kertolasku

varten ( int i = 0 ; i < tuotteet 1. koko ( ) ; i ++ ) {

tulos_tuotteet. työnnä takaisin ( tuotteet 1 [ i ] * tuotteet 2 [ i ] ) ;

}

// Näytä tuloksena oleva vektori

cout << 'Vektorin kertolasku: \n ' ;

varten ( int res : tulos_tuotteet )

cout << res << endl ;

}

Lähtö:

Iterointi - 1 : 10 * viisikymmentä => 500

Iterointi - 2 : kaksikymmentä * 40 => 800

Iterointi - 3 : 30 * 30 => 900

Iterointi - 4 : 40 * 70 => 2800

Iterointi - 5 : viisikymmentä * 60 => 3000

Kahden vektorin pistetulo

C++-vektorien tapauksessa pistetulo määritellään 'kahden vektorisekvenssin vastaavien merkintöjen tulojen summaksi'.

Syntaksi:

sisäinen_tuote ( Vektori1 ensin, Vektori1 viimeinen, Vektori2 ensin, Alkuarvo )

Käytä inner_product()-funktiota palauttaaksesi pistetulon. Tämä toiminto ottaa neljä vaadittua parametria.

Tässä:

Ensimmäinen parametri viittaa iteraattoriin, joka osoittaa ensimmäisen vektorin alkuun (määritä käyttämällä begin()-funktiota).
Toinen parametri viittaa iteraattoriin, joka osoittaa ensimmäisen vektorin loppuun (määritä käyttämällä end()-funktiota).
Kolmas parametri viittaa iteraattoriin, joka osoittaa toisen vektorin alkuun (määritä käyttämällä begin()-funktiota).
Alkuarvo on välitettävä viimeisenä parametrina, joka on kokonaisluku pistetulon kertymistä varten.

Käytä samaa ohjelmaa, joka on luotu kahden vektorin kertomiseen, ja käytä innsr_product()-funktiota löytääksesi kahden vektorin pistetulon.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo kaksi vektoria - tuotteet1 ja tuotteet2, joissa kummassakin on 5 elementtiä

vektori < int > tuotteet 1 = { 10 , kaksikymmentä , 30 , 40 , viisikymmentä } ;

vektori < int > tuotteet 2 = { viisikymmentä , 40 , 30 , 70 , 60 } ;

// Näytä tuloksena oleva vektori

cout << 'Tuotteiden1 ja tuotteiden2 pistetulo: ' ;

cout << sisäinen_tuote ( alkaa ( tuotteet 1 ) , loppu ( tuotteet 1 ) ,alkaa ( tuotteet 2 ) , 0 ) ;

}

Lähtö:

( 10 * viisikymmentä ) + ( kaksikymmentä * 40 ) + ( 30 * 30 ) + ( 40 * 70 ) + ( viisikymmentä * 60 )

=> 500 + 800 + 900 + 2800 + 3000

=> 8000

Muunna joukko vektoriksi

On monia tapoja muuntaa joukko vektoriksi välittämällä kaikki joukossa korotetut elementit vektoriksi. Paras ja yksinkertaisin tapa on käyttää std::copy()-funktiota.

Syntaksi

std :: kopio ( sourceIterator ensin, sourceIterator viimeisenä, destinationIterator ensin )

Käytä std::copy() funktio, joka lisää joukon alkiot vektoriin. Se vaatii kolme parametria.

Tässä:

Ensimmäinen parametri viittaa lähdeiteraattoriin, joka osoittaa iteraattorin ensimmäiseen elementtiin. Tässä set on lähdeiteraattori, joka määritetään begin()-funktiolla.
Vastaavasti toinen parametri osoittaa viimeiseen elementtiin (end()-funktio).
Kolmas parametri viittaa kohdeiteraattoriin, joka osoittaa iteraattorin ensimmäiseen elementtiin (määritetty aloitus()-funktiolla).

Luodaan viiden opiskelijan joukko ja kopioidaan kaikki elementit vektoriin käyttämällä edellistä funktiota.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo joukko - opiskelijat 5 elementillä

aseta < merkkijono > opiskelijat = { 'Sravan' , 'Bobby' , 'Madhu' , 'Meghana' , 'Lavanya' } ;

cout << 'Aseta: \n ' ;

varten ( merkkijono i : opiskelijat )

cout << i << endl ;

// Luo vektori - student_vcof-koko on yhtä suuri kuin joukon koko

vektori < merkkijono > opiskelija_vc ( opiskelijat. koko ( ) ) ;

// Lisää elementtejä joukosta - opiskelijat vektoriin - opiskelija_vc.

kopio ( opiskelijat. alkaa ( ) , opiskelijat. loppu ( ) , opiskelija_vc. alkaa ( ) ) ;

cout << ' \n Vektori: \n ' ;

varten ( merkkijono i : opiskelija_vc )

cout << i << endl ;

}

Lähtö:

Nyt kaikki 'Students'-joukossa olevat elementit kopioidaan 'students_vc'-vektoriin.

Poista päällekkäiset elementit

Ensin meidän on lajiteltava vektorin elementit niin, että kaikki kaksoiselementit ovat vierekkäin käyttämällä std::sort() toiminto.

järjestellä

(

)

;

Käytä std::unique()-funktiota, jotta päällekkäiset elementit valitaan. Käytä samalla erase()-funktiota poistaaksesi kaksoiskappaleet, jotka std::unique()-funktio palauttaa. Elementtien järjestys voi muuttua lopullisessa vektorissa.

pyyhkiä

(

ainutlaatuinen

(

)

Luo 'opiskelijoiden' vektori, jossa on 10 elementtiä ja palauta vektori poistamalla kaksoiskappaleet.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - opiskelijat 10 elementillä

vektori < merkkijono > opiskelijat = { 'Sravan' , 'Bobby' , 'Madhu' , 'Meghana' , 'Lavanya' ,

'Sravan' , 'Bobby' , 'Madhu' , 'Meghana' , 'Lavanya' } ;

cout << 'Opiskelijat: \n ' ;

varten ( merkkijono i : opiskelijat )

cout << i << ' ' ;

// Lajittele kaikki opiskelijavektorin elementit.

järjestellä ( alkaa ( opiskelijat ) , loppu ( opiskelijat ) ) ;

// Käytä ainutlaatuinen()-funktiota poistaaksesi kaksoiskappaleet erase()-funktiolla

opiskelijat. pyyhkiä ( ainutlaatuinen ( alkaa ( opiskelijat ) , loppu ( opiskelijat ) ) , loppu ( opiskelijat ) ) ;

cout << ' \n \n Ainutlaatuiset opiskelijat: \n ' ;

varten ( auto itr = cbegin ( opiskelijat ) ; itr ! = muutama ( opiskelijat ) ; ++ itr ) {

cout << * itr << ' ' ;

}

}

Lähtö:

Nyt kaikki elementit ovat ainutlaatuisia vektorissa.

Muunna vektori joukoksi

Set ei salli päällekkäisiä elementtejä. Jos kirjoitat lisätäksesi vektorin joukkoon, jossa on kaksoiskappaleita, ne ohitetaan. Käytämme samaa std::copy()-funktiota, jota käytettiin edellisessä skenaariossa, joka muunsi joukon vektoriksi.

Tässä skenaariossa:

Ensimmäinen parametri ottaa vektorin lähdeiteraattoriksi, joka määritellään begin()-funktiolla.
Toinen parametri ottaa vektorin lähdeiteraattoriksi, joka määritetään end()-funktiolla.
Ohita std::inserter()-funktio, jota käytetään elementtien päälle/kopioimiseen automaattisesti tietyssä kohdassa joukossa antamalla joukon ja iteraattorin, jotka osoittavat joukon loppuun parametreina.

Luodaan vektori, jossa on 10 kokonaislukua ja kopioidaan elementit joukoksi.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo joukko - merkit 10 arvolla

vektori < int > merkit = { 12 , 3. 4 , 56 , 78 , 65 , 78 , 90 , 90 , 78 , 3. 4 } ;

cout << 'Vektori: \n ' ;

varten ( int i : merkit )

cout << i << ' ' ;

// Luo joukko - marks_set, jonka koko on yhtä suuri kuin vektorin koko

aseta < int > marks_set ;

// Lisää elementtejä joukosta - opiskelijat vektoriin - opiskelija_vc.

kopio ( alkaa ( merkit ) , loppu ( merkit ) , syöttölaite ( marks_set,end ( marks_set ) ) ) ;

cout << ' \n \n Aseta: \n ' ;

varten ( int i : marks_set )

cout << i << ' ' ;

}

Lähtö:

Olemassa olevalla vektorilla nimeltä 'merkit' on 10 arvoa. Kun se on kopioitu 'marks_set' -joukkoon, siinä on vain kuusi elementtiä, koska muut neljä elementtiä kopioidaan.

Poista tyhjät merkkijonot

Tyhjiä merkkijonoja, jotka ovat vektorissa, ei käytetä. On hyvä käytäntö poistaa vektorissa olevat tyhjät merkkijonot. Katsotaanpa, kuinka tyhjät merkkijonot poistetaan C++-vektorista:

Iteroi vektoria käyttämällä 'for'-silmukkaa.
Tarkista jokaisessa iteraatiossa, onko elementti tyhjä ('') vai ei käytä '=='-operaattoria at()-jäsenfunktion kanssa.
Poista tyhjät merkkijonot std::erase()-funktiolla edellisen ehdon tarkistamisen jälkeen.
Toista vaiheet 2 ja 3 vektorin loppuun asti.

Luodaan 'yritykset' -vektori, jossa on 10 merkkijonoa. Niistä viisi on tyhjiä ja poistamme ne edellisen lähestymistavan avulla.

#include

#sisällytä

käyttämällä nimiavaruus std ;

pää ( ) {

vektori < merkkijono > yritykset { 'Yritys-A' , '' , 'Yritys-B' ,

'' , 'Yritys-C' , '' , 'Yritys-D' , '' , '' , '' } ;

// Iteroi yritysten yli

// ja poista tyhjät elementit käyttämällä erase()

varten ( int itr = 1 ; itr < yritykset. koko ( ) ; ++ itr ) {

jos ( yritykset. klo ( itr ) == '' ) {

yritykset. pyyhkiä ( yritykset. alkaa ( ) + itr ) ;

-- itr ;

}
}

// Näytä vektori

varten ( auto & i : yritykset ) {

cout << i << endl ;

}

}

Lähtö:

Nyt 'yritykset' -vektori sisältää ei-tyhjät merkkijonot.

Kirjoita vektori tekstitiedostoon

Keskustellaan kuinka kirjoitetaan kaikki vektorissa olevat elementit tiedostoon käyttämällä vektori-indeksejä käyttämällä fstream .

Työnnä siihen joitakin elementtejä push_back-funktiolla vektorin alustamisen jälkeen.
Käytä open()-funktiota 'fstream'-kirjastosta tilalla out.
Käy läpi jokainen vektorissa oleva elementti käyttämällä 'for'-silmukan indeksejä ja kirjoita jokainen elementti annettuun tiedostoon.
Lopuksi sulje tiedosto.

Toteutetaan edellinen lähestymistapa suorittamalla C++-koodi.

#sisällytä

#sisällytä

#include

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Luo vektori - v_data

// ja työnnä siihen kaksi elementtiä.

vektori < merkkijono > v_data ;

v_data. työnnä takaisin ( 'Tervetuloa' ) ;

v_data. työnnä takaisin ( 'LinuxHintille' ) ;

virta f ;

// Avaa tiedosto

f. avata ( 'kirjoitettu_tiedosto.txt' ,ios_base :: ulos ) ;

// Iteroi jokainen vektorin elementti ja kirjoita tiedostoon yksitellen.

varten ( int i = 0 ; i < v_data. koko ( ) ; i ++ )

{

f << v_data [ i ] << endl ;

}

// Sulje tiedosto

f. kiinni ( ) ;

}

Lähtö:

Vektori 'v_data' sisältää kaksi elementtiä ja tiedosto luodaan polulle, jossa ohjelma suoritetaan vektorissa olevilla elementeillä.

Luo vektori tekstitiedostosta

Opimme kirjoittamaan vektorissa olevat elementit tekstitiedostoon. Tässä luodaan vektori tekstitiedoston sisällöstä.

Luo ' ifstream” muuttuja, jota käytetään lukemaan tiedot tekstitiedostosta, johon luomme vektorin tiedostosta.
Luo tyhjä vektori tallentaaksesi tiedoston sisällön ja käytä tyhjää merkkijonomuuttujaa lippuna tarkistaaksesi tiedoston lopun.
Lue tiedostosta seuraava rivi, kunnes se saavuttaa sen loppuun (periaatteessa 'while'-silmukan avulla). Käytä push_back()-funktiota seuraavan rivin lukemiseen ja työnnä se vektoriin.
Näytä rivillä oleva viiva erikseen nähdäksesi elementit, jotka ovat konsolin vektorissa.

Toteutetaan edellinen lähestymistapa suorittamalla C++-koodi. Tarkastellaan 'data.txt'-tiedostoa, jossa on seuraava sisältö. Tässä vektorin nimi on 'v_data'.

#include

käyttämällä nimiavaruus std ;

pää ( )

{

// Avaa tekstitiedosto - data
ifstream-tiedosto ( 'data.txt' ) ;

// Luo vektori - v_data tyyppiä - merkkijono

vektori < merkkijono > v_data ;

stringi oli ;

// Lue seuraava rivi data.txt-tiedostosta
// kunnes se saavuttaa lopun.

sillä aikaa ( tiedosto >> oli ) {

// Lue seuraava rivi ja paina v_data

v_data. työnnä takaisin ( oli ) ;

}

// Näytä rivillä oleva rivi erikseen.

kopio ( v_data. alkaa ( ) , v_data. loppu ( ) , ostream_iterator < merkkijono > ( cout , ' \n ' ) ) ;

}

Lähtö:

Voimme nähdä, että 'v_data' sisältää viisi elementtiä, jotka tulivat tiedostosta.

Johtopäätös

Tässä pitkässä artikkelissa tutkimme kaikkia mahdollisia esimerkkejä, joita käytetään C++-ohjelmointikielen vektoreihin liittyvissä reaaliaikaisissa sovelluksissa. Jokainen esimerkki selitetään syntaksin, parametrien ja esimerkin kanssa tulosteen kanssa. Jokaiseen koodiin lisätään kommentteja, jotta koodista saadaan selkeä käsitys.