30 C++ vektorite näiteid

C++ keeles on Vector ühemõõtmeline andmestruktuur, mis dünaamiliselt suureneb vastavalt vajadusele. Andmete organiseerimine (sisestamine/muutmine/kustutamine) saab selles andmestruktuuris tõhusalt teostatav. Selle rakendused hõlmavad järgmist:

Matemaatiliste vektorite kujutamine teadus- ja tehnikarakendustes
Seda andmestruktuuri kasutades saab realiseerida järjekordi, virnasid jne.

Enamikku selle andmestruktuuriga seotud tavalisi CRUD-i toiminguid ja funktsioone käsitletakse üksikasjalikult stsenaariumipõhiselt koos süntaksi ja koodijuppidega.

Sisu teema:

Sisestage element vektorisse
Sisestage vektorisse mitu elementi
Juurdepääs elementidele vektorist
Värskendage elementi vektoris
Konkreetse elemendi eemaldamine vektorist
Eemaldage vektorist kõik elemendid
Vektorite Liit
Vektorite ristumiskoht
Kontrollige, kas vektor on tühi või mitte
Vektori läbimine Const_Iteratori abil
Vektori läbimine Reverse_Iteratori abil
Lükake elemendid vektorisse
Popige elemendid vektorist
Vahetage vektorid
Tõmba esimene element vektorist
Tõmba viimane element vektorist
Määrake vektorile uued väärtused
Laiendage vektorit Emplace() abil
Laiendage vektorit kasutades Emplace_Back()
Vektori maksimaalne element
Vektori minimaalne element
Elementide summa vektoris
Kahe vektori elemendipõhine korrutamine
Kahe vektori punktkorrutis
Teisendage komplekt vektoriks
Eemaldage dubleerivad elemendid
Teisendage vektor komplektiks
Eemaldage tühjad stringid
Kirjutage tekstifaili vektor
Looge tekstifailist vektor

Sisestage element vektorisse

The std::vector::insert() funktsiooni C++ STL-is kasutatakse elementide sisestamiseks määratud kohta.

Süntaks:

vektor. sisestada ( asend, element ) ;

Kasutame seda funktsiooni ja edastame esimese positsiooni parameetrina, mis määrab asukoha, kuhu element tuleb sisestada, ja esitame elemendi teise parameetrina.

Funktsiooni begin() saab siin kasutada, et tagastada iteraator, mis osutab sisendvektori esimesele elemendile. Lisades sellele funktsioonile positsiooni, sisestatakse element sellesse kohta.

Loome stringi tüüpi vektori 'õpilase_nimed' ja sisestame funktsiooni insert() abil üksteise järel kaks stringi esimesse ja teise positsiooni.

#include

kasutades nimeruum std ;

peamine ( )

{

// Vektori initsialiseerimine - õpilaste_nimed

vektor < string > õpilaste_nimed ;

cout << 'Olemasolev vektor: \n ' ;

jaoks ( auto i : õpilaste_nimed ) cout << i << endl ;

// Sisestage 'Sravan Kumar' esimesse kohta

õpilaste_nimed. sisestada ( õpilaste_nimed. alustada ( ) + 0 , 'Shravan Kumar' ) ;

// Sisestage 'Sravan Kumar' teisele kohale

õpilaste_nimed. sisestada ( õpilaste_nimed. alustada ( ) + 1 , 'Lalitha' ) ;

cout << 'Lõplik vektor: \n ' ;

jaoks ( auto j : õpilaste_nimed ) cout << j << endl ;

}

Väljund:

Varem oli vektor „õpilaste_nimed” tühi. Pärast sisestamist sisaldab vektor kahte elementi.

Sisestage vektorisse mitu elementi

Selles stsenaariumis kasutame sama funktsiooni, mis on std::vector::insert(). Kuid peame vektorisse mitme elemendi sisestamiseks edastama samale funktsioonile lisa-/erinevad parameetrid.

1. stsenaarium: ühe elemendi sisestamine mitu korda

Selle stsenaariumi korral lisame sama elemendi mitu korda.

Süntaks:

vektor. sisestada ( asend, suurus, element ) ;

Selleks peame suuruse teise parameetrina edastama funktsioonile insert(). Sellele funktsioonile edastatakse kokku kolm parameetrit.

Siin:

Positsiooniparameeter määrab sisestatava elemendi asukoha. Kui suurus on suurem kui 1, on lähtepositsiooni indeks positsioon.
Suuruse parameeter määrab, mitu korda elementi tuleb sisestada.
Elemendi parameeter võtab vektorisse sisestatava elemendi.

Mõelge kahe stringiga vektorile 'õpilase_nimed'. Sisestage 'Lavanya' stringid viis korda teise asendisse.

#include

kasutades nimeruum std ;

peamine ( )

{

// Vektori initsialiseerimine - õpilaste_nimed

vektor < string > õpilaste_nimed { 'Shravan Kumar' , 'Lalitha' } ;

cout << 'Olemasolev vektor: \n ' ;

jaoks ( auto i : õpilaste_nimed ) cout << i << endl ;

// Sisestage 'Lavanya' teisele positsioonile 5 korda

õpilaste_nimed. sisestada ( õpilaste_nimed. alustada ( ) + 1 , 5 , 'Lavanya' ) ;

cout << ' \n Lõplik vektor: \n ' ;

jaoks ( auto j : õpilaste_nimed ) cout << j << endl ;

}

Väljund:

Olemasolevas vektoris on 'Sravan Kumar' esimesel positsioonil ja 'Lalitha' teisel positsioonil. Pärast “Lavanya” viit korda sisestamist (teiselt positsioonilt kuuendale positsioonile) liikus “Lalitha” seitsmendale positsioonile (viimasele).

2. stsenaarium: mitme elemendi sisestamine

Selle stsenaariumi korral lisame erinevad elemendid korraga teisest vektorist. Kasutame ka siin sama funktsiooni, kuid süntaks ja parameetrid muutuvad.

Süntaks:

vektor. sisestada ( positsioon, esimene_iteraator, teine_iteraator ) ;

Selleks peame suuruse teise parameetrina edastama funktsioonile insert(). Sellele funktsioonile edastatakse kokku kolm parameetrit.

Siin:

Positsiooniparameeter määrab sisestatava elemendi asukoha.
'First_iterator' määrab lähtepositsiooni, kust elemendid sisestatakse (põhimõtteliselt tagastatakse funktsiooni begin() abil iteraator, mis osutab konteineris olevale esimesele elemendile).
'Second_iterator' määrab lõpupositsiooni, milleni elemendid sisestatakse (põhimõtteliselt, kasutades end() funktsiooni, tagastatakse iteraator, mis osutab konteineris oleva viimase punkti kõrvale).

Looge kaks täisarvu tüüpi vektorit, 'marks1' ja 'marks2'. Sisestage kõik elemendid, mis on vektoris 'marks2' vektori 'marks1' esimesse kohta.

#include

kasutades nimeruum std ;

peamine ( )

{

// Vektori initsialiseerimine - märgid1

vektor < int > märgid1 { 100 , 89 , 90 , 78 , 98 } ;

cout << 'Esimene vektor: \n ' ;

jaoks ( auto i : märgid1 ) cout << i << endl ;

// Vektori initsialiseerimine - märgid2

vektor < int > märgid2 { 56 , Neli, viis , 65 } ;

cout << 'Teine vektor: \n ' ;

jaoks ( auto j : märgid2 ) cout << j << endl ;

märgid1. sisestada ( alustada ( märgid1 ) , alusta ( märgid2 ) , lõpp ( märgid 2 ) ) ;

// Lõplik vektor

cout << 'Esimene viimane vektor: \n ' ;

jaoks ( auto x : märgid1 )

cout << x << ' ' ;

}

Väljund:

Esimene vektor (marks1) sisaldab viit elementi ja teine vektor (marks2) sisaldab kolme elementi. Edendasime parameetrid algus (marks1), begin (marks2), end (marks2) funktsioonile 'insert', nii et kõik teises vektoris olevad elemendid itereeritakse ja sisestatakse alguses esimesse vektorisse. Niisiis, esimene vektor sisaldab kaheksat elementi.

Juurdepääs elementidele vektorist

1. Operaatori [] kasutamine

Mõne stsenaariumi korral võib teil olla nõue tagastada vektorist ainult konkreetsed elemendid. Kõiki elemente pole vaja tagastada. Seega, et tagastada ainult konkreetsed indeksil põhinevad elemendid, kasutatakse indeksi operaatorit ja at() funktsioone.

Süntaks:

vektor [ indeks_positsioon ]

C++ puhul algab indekseerimine mis tahes andmestruktuuri puhul nullist. Kui elementi pole olemas, tagastatakse see tühjana (viga puudub või hoiatust ei kuvata).

Mõelge viie elemendiga toodete vektorile. Juurdepääs kõigile elementidele ükshaaval, kasutades indeksi asukohta.

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – 5 stringiga tooted

vektor < string > tooted { 'seep' , 'šampoon' , 'õli' , 'puuviljad' , 'köögiviljad' } ;

//Juurdepääs toodetest elementidele

cout << 'Esimene element:' << tooted [ 0 ] << endl ;

cout << 'Teine element:' << tooted [ 1 ] << endl ;

cout << 'Kolmas element:' << tooted [ 2 ] << endl ;

cout << 'Neljas element:' << tooted [ 3 ] << endl ;

cout << 'Viies element:' << tooted [ 4 ] << endl ;

// Proovige pääseda 9. elemendile

cout << 'Üheksas element:' << tooted [ 8 ] << endl ;

}

Väljund:

Indeksis 8 pole elementi. Seega tagastatakse tühi.

2. Funktsiooni At() kasutamine

At() on liigefunktsioon, mis sarnaneb eelmisele kasutusjuhtumile, kuid tagastab erandi „std::vahemikust_väljas”, kui talle antakse indeks väljaspool vahemikku.

Süntaks:

vektor. juures ( indeks_positsioon )

Peame sellele funktsioonile edastama indeksi positsiooni.

Mõelge viie elemendiga toodete vektorile. Juurdepääs kõigile elementidele ükshaaval, kasutades indeksi positsiooni ja proovige pääseda juurde elemendile, mis asub 9. positsioonil.

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – 5 stringiga tooted

vektor < string > tooted { 'seep' , 'šampoon' , 'õli' , 'puuviljad' , 'köögiviljad' } ;

//Juurdepääs toodetest elementidele

cout << 'Esimene element:' << tooted. juures ( 0 ) << endl ;

cout << 'Teine element:' << tooted. juures ( 1 ) << endl ;

cout << 'Kolmas element:' << tooted. juures ( 2 ) << endl ;

cout << 'Neljas element:' << tooted. juures ( 3 ) << endl ;

cout << 'Viies element:' << tooted. juures ( 4 ) << endl ;

//Juurdepääs vektoris mitteolevatele elementidele

cout << 'Üheksas element:' << tooted. juures ( 8 ) << endl ;

}

Väljund:

9. elemendile juurdepääsul ilmneb viga:

terminate kutsutakse pärast eksemplari viskamist 'std::vahemikust_väljas'

mida ( ) : vektor :: _M_vahemiku_kontroll : __n ( mis on 8 ) >= see - > suurus ( ) ( mis on 5 )

Värskendage elementi vektoris

1. Operaatori [] kasutamine

Indeksi positsiooni kasutades saame elementi vektoris värskendada. Operaator [] võtab värskendatava elemendi indeksi asukoha. Uus element määratakse sellele operaatorile.

Süntaks:

Vektor [ indeks_positsioon ] = Element

Mõelge viie väärtusega vektorile 'õpilase_märgid'. Värskendage indeksite 1 ja 3 juures olevaid elemente.

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor - õpilase_märgid

vektor < int > õpilase_märgid { 98 , 78 , 90 , 67 , 89 } ;

cout << 'Olemasolevad märgid:' << endl ;

jaoks ( int itr : õpilase_märgid )

cout << itr << endl ;

// Värskenda elementi indeksis 3 100-ga

õpilase_märgid [ 3 ] = 100 ;

// Värskenda elementi indeksi 1 juures 60-ga

õpilase_märgid [ 1 ] = 60 ;

cout << 'Lõppmärgid:' << endl ;

jaoks ( int itr : õpilase_märgid )

cout << itr << endl ;

}

Väljund:

Näeme, et lõplik vektor hoiab värskenduselemente indeksite 1 ja 3 juures.

2. Funktsiooni At() kasutamine

Sarnaselt indeksioperaatoriga on at() põhimõtteliselt liigefunktsioon, mis värskendab väärtust iteraatori indeksi põhjal. Kui selle funktsiooni sees määratud indeksit ei eksisteeri, visatakse välja erand „std::out_of_range”.

vektor. juures ( indeks_positsioon ) = Element

Mõelge viie elemendiga toodete vektorile. Värskendage kõiki vektoris olevaid elemente teiste elementidega.

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – 5 stringiga tooted

vektor < string > tooted { 'seep' , 'šampoon' , 'õli' , 'puuviljad' , 'köögiviljad' } ;

cout << 'Olemasolevad tooted:' << endl ;

jaoks ( string itr : tooted )

cout << itr << endl ;

//Kõigi stringide värskendamine

tooted. juures ( 0 ) = 'Kook' ;

tooted. juures ( 1 ) = 'Šokolaad' ;

tooted. juures ( 2 ) = 'Puuviljad' ;

tooted. juures ( 3 ) = 'sibul' ;

tooted. juures ( 4 ) = 'Karastusjoogid' ;

cout << ' \n Lõpptooted: ' << endl ;

jaoks ( string itr : tooted )

cout << itr << endl ;

}

Väljund:

Konkreetse elemendi eemaldamine vektorist

C++ keeles on std::vektor::kustuta() funktsiooni kasutatakse konkreetse elemendi/elementide vahemiku eemaldamiseks vektorist. Elemendid eemaldatakse iteraatori positsioonide alusel.

Süntaks:

vektor. kustutada ( iteraatori asukoht )

Vaatame süntaksit konkreetse elemendi vektorist eemaldamiseks. Eemaldatavas vektoris oleva elemendi asukoha leidmiseks saame kasutada funktsioone begin() või end().

Mõelge viie elemendiga toodete vektorile.

Eemaldage kolmas element, määrates iteraatori begin(). Begin() osutab vektori esimesele elemendile. Kui lisame sellele funktsioonile kaks, osutab see kolmandale elemendile.
Eemaldage viimane element, määrates end() iteraatori. End() osutab vektori viimasele elemendile.

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – 5 stringiga tooted

vektor < string > tooted { 'seep' , 'šampoon' , 'õli' , 'puuviljad' , 'köögiviljad' } ;

cout << 'Olemasolevad tooted:' << endl ;

jaoks ( string itr : tooted )

cout << itr << endl ;

// Eemalda 3. element

tooted. kustutada ( tooted. alustada ( ) + 2 ) ;

cout << ' \n Pärast 3. elemendi eemaldamist: \n ' ;

jaoks ( string itr : tooted )

cout << itr << endl ;

// Eemalda viimane element

tooted. kustutada ( tooted. lõpp ( ) ) ;

cout << ' \n Pärast viimase elemendi eemaldamist: \n ' ;

jaoks ( string itr : tooted )

cout << itr << endl ;

}

Väljund:

Nüüd on 'toodete' vektoris ainult kolm elementi ('seep', 'šampoon', 'puuviljad').

Eemaldage vektorist kõik elemendid

1. stsenaarium: eemaldage vektorist elementide vahemik

Kasutame funktsiooni std::vector::erase() mitme elemendi eemaldamiseks vahemikus.

Süntaks:

vektor. kustutada ( iteraator esimene, iteraator viimane )

Vahemiku täpsustamiseks kasutatakse kahte iteraatorit (begin() osutab esimesele elemendile ja end() osutab viimasele elemendile).

Mõelge viie elemendiga 'toodete' vektorile ja eemaldage kõik elemendid teisest positsioonist. Selle saavutamiseks on esimene iteraator algus (produktid)+1, mis osutab teisele elemendile ja teine iteraator lõpp (tooted).

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – 5 stringiga tooted

vektor < string > tooted { 'seep' , 'šampoon' , 'õli' , 'puuviljad' , 'köögiviljad' } ;

cout << 'Olemasolevad tooted:' << endl ;

jaoks ( string itr : tooted )

cout << itr << endl ;

// Eemaldage kõik elemendid teisest positsioonist

tooted. kustutada ( alustada ( tooted ) + 1 ,lõpp ( tooted ) ) ;

cout << ' \n Lõpptooted: \n ' ;

jaoks ( string itr : tooted )

cout << itr << endl ;

}

Väljund:

Nüüd on 'toodete' vektoris ainult üks element ('seep').

2. stsenaarium: eemaldage vektorist kõik elemendid

Kasutame std::vector::clear() funktsioon vektorist kõigi elementide eemaldamiseks.

Süntaks:

vektor. selge ( )

Sellele funktsioonile ei edastata parameetreid.

Mõelge samale vektorile, mida kasutati esimeses stsenaariumis, ja eemaldage kõik elemendid funktsiooni clear() abil.

Väljund:

Näeme, et 'produktide' vektoris pole elemente.

Vektorite Liit

Funktsiooni std::set_union() abil on võimalik teostada vektoritega UNION-operatsiooni. Liit tagastab unikaalsed elemendid vektoritest, ignoreerides dubleerivaid elemente. Peame mõlemad iteraatorid sellele funktsioonile edastama. Koos sellega tuleb läbida väljunditeraator, mis salvestab mõlema iteraatori tagastatud tulemuse.

Süntaks:

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

Siin:

'First1' osutab esimese iteraatori (vektori) esimesele elemendile.
'Last1' osutab esimese iteraatori (vektori) viimasele elemendile.
'First2' osutab teise iteraatori (vektori) esimesele elemendile.
'Last2' osutab teise iteraatori (vektori) viimasele elemendile.

Looge kaks täisarvu tüüpi vektorit – “subjects1” ja “subjects2”.

Sorteerige kaks vektorit funktsiooni sort() abil, jättes iteraatorid.
Looge väljundvektor (iteraator).
Leidke nende kahe vektori liit, kasutades funktsiooni std::set_union(). Kasutage algust() esimese iteraatorina ja end() viimase iteraatorina.
Funktsiooni tagastatud elementide kuvamiseks korrake väljundvektorit.

#include

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor - märgid1

vektor < int > märgid1 = { 100 , 90 , 80 , 70 , 60 } ;

// Loo vektor - marks2

vektor < int > märgid 2 = { 80 , 90 , 60 , 70 , 100 } ;

// Sorteeri mõlemad vektorid

sorteerida ( märgid1. alustada ( ) , märgid1. lõpp ( ) ) ;

sorteerida ( märgid2. alustada ( ) , märgid2. lõpp ( ) ) ;

vektor < int > väljundvektor ( märgid1. suurus ( ) + märgid2. suurus ( ) ) ;

vektor < int > :: iteraator on ;

i = komplekt_liit ( märgid1. alustada ( ) , märgid1. lõpp ( ) ,

märgid2. alustada ( ) ,märgid2. lõpp ( ) ,

väljundvektor. alustada ( ) ) ;

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

jaoks ( s = väljundvektor. alustada ( ) ; s ! = i ; ++ s )

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

}

Väljund:

Mõlemas vektoris (subjektid1 ja subjektid2) on ainult viis ainulaadset elementi.

Vektorite ristumiskoht

Kahe vektori ristumiskoha leidmine on võimalik funktsiooni std::set_intersection() abil. Ristmik tagastab elemendid, mis esinevad mõlemas vektoris.

Süntaks:

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

Funktsioonile set_union() edastatavad parameetrid saab edastada ka sellele funktsioonile set_intersection().

Looge kaks täisarvu tüüpi vektorit – “subjects1” ja “subjects2”.

Sorteerige kaks vektorit funktsiooni sort() abil, edastades iteraatorid.
Looge väljundvektor (iteraator).
Leidke nende kahe vektori ristumiskoht funktsiooni std::set_intersection() abil. Kasutage algust() esimese iteraatorina ja end() viimase iteraatorina.
Funktsiooni tagastatud elementide kuvamiseks korrake väljundvektorit.

#include

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor - märgid1

vektor < int > märgid1 = { 100 , 10 , 80 , 40 , 60 } ;

// Loo vektor - marks2

vektor < int > märgid 2 = { viiskümmend , 90 , 60 , 10 , 100 } ;

// Sorteeri mõlemad vektorid

sorteerida ( märgid1. alustada ( ) , märgid1. lõpp ( ) ) ;

sorteerida ( märgid2. alustada ( ) , märgid2. lõpp ( ) ) ;

vektor < int > väljundvektor ( märgid1. suurus ( ) + märgid2. suurus ( ) ) ;

vektor < int > :: iteraator on ;

i = sea_ristmik ( märgid1. alustada ( ) , märgid1. lõpp ( ) ,

märgid2. alustada ( ) ,märgid2. lõpp ( ) ,

väljundvektor. alustada ( ) ) ;

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

jaoks ( s = väljundvektor. alustada ( ) ; s ! = i ; ++ s )

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

}

Väljund:

Mõlemas vektoris (subjektid1 ja subjektid2) on ainult kolm elementi.

Kontrollige, kas vektor on tühi või mitte

Enne vektorite kallal töötamist on oluline kontrollida, kas vektor on tühi või mitte. Samuti on tarkvaraprojektides hea tava kontrollida, kas vektor on tühi või mitte, enne selliste toimingute tegemist nagu CRUD-toimingud jne.

1. Std::vector::empty() kasutamine

See funktsioon tagastab 1, kui vektor on tühi (ei sisalda ühtegi elementi). Vastasel juhul tagastatakse 0. Sellele funktsioonile ei edastata ühtegi parameetrit.

2. Kasutades Std::vektor::suurus()

Funktsioon std::vector::size() tagastab täisarvu, mis tähistab vektoris esinevate elementide koguarvu.

Looge kaks vektorit – 'kolledž1' ja 'kolledž2'. 'College1' sisaldab viit elementi ja 'kolledž2' on tühi. Rakendage mõlemad funktsioonid mõlemale vektorile ja kontrollige väljundit.

#include

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – kolledž1

vektor < string > kolledž 1 = { 'kolledž-A' , 'kolledž-B' , 'kolledž-C' , 'kolledž-D' , 'kolledž-E' } ;

// Loo vektor – kolledž2

vektor < string > kolledž 2 ;

// tühi()

cout << kolledž 1. tühi ( ) << endl ;

cout << kolledž 2. tühi ( ) << endl ;

// suurus()

cout << kolledž 1. suurus ( ) << endl ;

cout << kolledž 2. suurus ( ) << endl ;

}

Väljund:

Funktsioon tühi () tagastab 0 “kolledž1” ja 1 “kolledž2” jaoks. Funktsioon size() tagastab väärtuse “kolledž1” jaoks viis ja “kolledž2” jaoks 0.

Vektori läbimine Const_Iteratori abil

Kui töötate C++ konteineritega, nagu komplektid, vektorid jne, on võimalik itereerida kõiki konteineris olevaid elemente neid muutmata. The const_iterator on üks iteraatoritest, kes selle stsenaariumi saavutab. cbegin() (osutab vektori esimesele elemendile) ja cend() (osutab vektori viimasele elemendile) on iga konteineri kaks funktsiooni, mida kasutatakse konstantse iteraatori tagastamiseks vektori algusesse ja lõppu. konteiner. Vektorit itereerides saame kasutada neid kahte funktsiooni.

Loome viie stringiga vektori nimega 'osakonnad'.
Deklareerige const_iterator – ctr tüübiga .
Itereerige osakondade üle, kasutades eelmist iteraatorit, kasutades tsüklit 'for' ja kuvage see.

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor - osakonnad

vektor < string > osakonnad = { 'Müük' , 'Teenus' ,

'HR' , 'IT' , 'Teised' } ;

vektor < string > :: const_iterator ctr ;

// Osakondade itereerimine kasutades const_iterator - ctr.

jaoks ( ctr = osakonnad. cbegin ( ) ; ctr ! = osakonnad. mõni ( ) ; ctr ++ ) {

cout << * ctr << endl ;

}

}

Väljund:

Vektori läbimine, kasutades funktsiooni Reverse_Iterator

The reverse_iterator on ka iteraator, mis sarnaneb const_iteratoriga, kuid tagastab elemendid vastupidises järjekorras. rbegin() (osutab vektori viimasele elemendile) ja rend() (osutab vektori esimesele elemendile) on iga konteineri kaks funktsiooni, mida kasutatakse konstantse iteraatori tagastamiseks vektori lõppu ja algusesse. konteiner.

Loome viie stringiga vektori nimega 'osakonnad'.
Deklareerige reverse_iterator – rtr tüübiga .
Itereerige osakondade üle, kasutades eelmist iteraatorit, kasutades tsüklit 'for' ja kuvage see.

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor - osakonnad

vektor < string > osakonnad = { 'Müük' , 'Teenus' ,

'HR' , 'IT' , 'Teised' } ;

vektor < string > :: reverse_iterator rtr ;

// Itereerige osakondades kasutades reverse_iterator - rtr.

jaoks ( rtr = osakonnad. rbegin ( ) ; rtr ! = osakonnad. teeb ( ) ; rtr ++ ) {

cout << * rtr << endl ;

}

}

Väljund:

Lükake elemendid vektorisse

Elementide surumine või lisamine vektorisse on ühesuunaline sisestamine, mida saab teha kasutades vektor::push_back() funktsiooni.

Süntaks:

vektor. lükka tagasi ( element )

Selleks on vaja elementi, mis lükatakse vektorisse parameetrina.

Loome viie stringiga tühja vektori nimega 'osakonnad' ja lükkame kaks stringi üksteise järel, kasutades funktsiooni push_back().

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Initsialiseeri vektor - osakonnad

vektor < string > osakonnad ;

cout << 'Tegelikud osakonnad:' << endl ;

jaoks ( auto itr = osakonnad. alustada ( ) ; itr ! = osakonnad. lõpp ( ) ; ++ itr )

cout << * itr << endl ;

// Lükake 'Müük'

osakonnad. lükka tagasi ( 'Müük' ) ;

// Lükake'

osakonnad. lükka tagasi ( 'IT' ) ;

cout << ' \n Lõpuosakonnad:' << endl ;

jaoks ( auto itr = osakonnad. alustada ( ) ; itr ! = osakonnad. lõpp ( ) ; ++ itr )

cout << * itr << endl ;

}

Väljund:

Esiteks vajutame 'Müük'. Pärast seda lükatakse 'IT' vektorisse. Nüüd sisaldab 'osakondade' vektor kahte elementi.

Popige elemendid vektorist

Kui soovite kustutada viimase vektoris oleva üksuse, kasutage vektor::pop_back() funktsioon on parim lähenemisviis. See kustutab vektoris viimase elemendi.

Süntaks:

vektor. pop_back ( )

Selle funktsiooni jaoks pole parameetrit vaja. See näitab määratlemata käitumist, kui proovime kustutada viimast elementi tühjast vektorist.

Loome viie stringiga tühja vektori nimega 'osakonnad' ja kustutame eelmise funktsiooni abil viimase elemendi. Kuvage vektor mõlemal juhul.

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Initsialiseeri vektor - osakonnad

vektor < string > osakonnad = { 'Müük' , 'IT' , 'Teenus' , 'Turundus' , 'HR' } ;

cout << 'Tegelikud osakonnad:' << endl ;

jaoks ( auto itr = osakonnad. alustada ( ) ; itr ! = osakonnad. lõpp ( ) ; ++ itr )

cout << * itr << endl ;

// Kustutage viimane element

osakonnad. pop_back ( ) ;

cout << ' \n Lõpuosakonnad:' << endl ;

jaoks ( auto itr = osakonnad. alustada ( ) ; itr ! = osakonnad. lõpp ( ) ; ++ itr )

cout << * itr << endl ;

}

Väljund:

'HR' on viimane element, mis on vektoris 'osakonnad'. Seega eemaldatakse see vektorist ja lõplik vektor sisaldab 'Müük', 'IT', 'Teenus' ja 'Turundus'.

Vahetage vektorid

The vektor::swap() C++ STL-i funktsiooni kasutatakse kõigi kahes vektoris esinevate elementide vahetamiseks.

Süntaks:

esimene_vektor. vahetus ( teine_vektor )

See ei võta arvesse vektorite suurust, kuid vektorid peaksid olema sama tüüpi (erinevate vektoritüüpide korral kuvatakse viga).

Loome kaks erineva suurusega stringi tüüpi vektorit – 'puuviljad' ja 'juurviljad'. Vahetage igaüks neist ja kuvage vektorid mõlemal juhul.

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Initsialiseeri vektor - puuviljad

vektor < string > puuviljad = { 'Õun' , 'Mango' } ;

cout << 'Tegelikud puuviljad:' << endl ;

jaoks ( auto itr = puuviljad. alustada ( ) ; itr ! = puuviljad. lõpp ( ) ; ++ itr )

cout << * itr << endl ;

// Initsialiseeri vektor - köögiviljad

vektor < string > köögiviljad = { 'Kartul' , 'tomat' , 'Brinjal' } ;

cout << ' \n Tegelikud köögiviljad:' << endl ;

jaoks ( auto itr = köögiviljad. alustada ( ) ; itr ! = köögiviljad. lõpp ( ) ; ++ itr )

cout << * itr << endl ;

// Vahetage mõlema vektori elemendid

puuviljad. vahetus ( köögiviljad ) ;

cout << ' \n Puuviljad pärast vahetamist:' << endl ;

jaoks ( auto itr = puuviljad. alustada ( ) ; itr ! = puuviljad. lõpp ( ) ; ++ itr )

cout << * itr << endl ;

cout << ' \n Köögiviljad pärast vahetamist:' << endl ;

jaoks ( auto itr = köögiviljad. alustada ( ) ; itr ! = köögiviljad. lõpp ( ) ; ++ itr )

cout << * itr << endl ;

}

Väljund:

Varem sisaldab 'puuviljade' vektor kahte elementi ja 'köögiviljade' vektor kolm elementi. Pärast vahetamist sisaldab 'puuviljade' vektor kolm elementi ja 'köögiviljade' vektor kaks elementi.

Tõmba esimene element vektorist

Mõnel juhul on nõue tagastada vektorist ainult esimene element. Funktsioon vektor::front() C++ STL-is toob vektorist ainult esimese elemendi.

Süntaks:

vektor. ees ( )

See funktsioon ei kasuta ühtegi parameetrit. Kui vektor on tühi, kuvatakse viga.

Loome kaks stringi tüüpi vektorit – 'puuviljad' ja 'juurviljad' - ja proovime tuua esimese elemendi kahest vektorist eraldi.

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – 2 elemendiga puuviljad

vektor < string > puuviljad = { 'Õun' , 'Mango' } ;

// Tagastab esimese elemendi

cout << puuviljad. ees ( ) << endl ;

// Initsialiseeri vektor - köögiviljad

vektor < string > köögiviljad ;

// Proovige esimest elementi tagastada

cout << köögiviljad. ees ( ) ;

}

Väljund:

'Õun' on esimene element, mis on 'puuviljade' vektoris. Niisiis, see tagastatakse. Kuid kui proovime tuua esimest elementi 'köögiviljade' vektorist, kuvatakse viga, kuna see on tühi.

Tõmba viimane element vektorist

Funktsioon vektor::end() C++ STL-is toob vektorist ainult viimase elemendi.

Süntaks:

vektor. tagasi ( )

See funktsioon ei võta ühtegi parameetrit. Kui vektor on tühi, kuvatakse viga.

Loome kaks stringi tüüpi vektorit – 'puuviljad' ja 'juurviljad' - ja proovime tuua viimase elemendi kahest vektorist eraldi.

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – 2 elemendiga puuviljad

vektor < string > puuviljad = { 'Õun' , 'Mango' } ;

// Viimase elemendi toomine

cout << puuviljad. tagasi ( ) << endl ;

// Initsialiseeri vektor - köögiviljad

vektor < string > köögiviljad ;

// Proovige tuua viimane element

cout << köögiviljad. tagasi ( ) ;

}

Väljund:

'Mango' on viimane element, mis on 'puuviljade' vektoris. Niisiis, see tagastatakse. Kuid viga ilmub siis, kui püüame tuua viimast elementi 'köögiviljade' vektorist, kuna see on tühi.

Määrake vektorile uued väärtused

Mõne stsenaariumi korral, kui soovite värskendada kõiki väärtusi uue väärtusega või luua samade väärtustega vektori, on funktsiooni vektor::assign() kasutamine parim viis. Seda funktsiooni kasutades saame:

Looge vektor kõigi sarnaste elementidega
Muutke olemasolevat vektorit sama elemendiga

Süntaks:

vektor. määrama ( suurus, väärtus )

Selle funktsiooni jaoks on vaja kahte parameetrit.

Siin:

Suurus määrab määratavate elementide arvu.
Väärtus määrab määratava elemendi.

Loome viie väärtusega vektori nimega 'marks1' ja värskendame seda vektorit nelja elemendiga nii, et kõik värskendatud vektori elemendid oleksid võrdsed 20-ga.

#include

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor - märgid1

vektor < int > märgid1 = { 100 , 90 , 80 , 70 , 60 } ;

cout << 'Tegelik vektor:' << endl ;

jaoks ( int i = 0 ; i < märgid1. suurus ( ) ; i ++ )

cout << märgid1 [ i ] << endl ;

märgid1. määrama ( 4 , kakskümmend ) ;

cout << ' \n Uuendatud vektor:' << endl ;

jaoks ( int i = 0 ; i < märgid1. suurus ( ) ; i ++ )

cout << märgid1 [ i ] << endl ;

}

Väljund:

Varem on vektoris viis erinevat elementi. Nüüd sisaldab see ainult nelja elementi ja kõik on võrdsed 20-ga.

Laiendage vektorit Emplace() abil

Teame juba, et uued elemendid sisestatakse dünaamiliselt vektori mis tahes kohta. See on võimalik funktsiooni vektor::emplace() abil. Vaatame kiiresti selle funktsiooni poolt aktsepteeritud süntaksit ja parameetreid.

Süntaks:

vektor. asukoht ( const_iterator asukoht, element )

Sellele funktsioonile antakse edasi kaks kohustuslikku parameetrit.

Siin:

Esimene parameeter võtab positsiooni, nii et saame elemendi sisestada mis tahes asendisse. Positsiooni saame kasutada iteraatori funktsiooni begin() või end() abil.
Teine parameeter on vektorisse sisestatav element.

Mõelge kahe elemendiga 'kemikaalide' vektorile.

Sisestage 'Mangaan' esimesse kohta – algus (kemikaalid)
Sisestage 'vask' viimasesse kohta - lõpp (kemikaalid)
Kolmandale kohale sisestage ‘Sulphur’ – algus(kemikaalid)+2

#include

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – kemikaalid

vektor < string > kemikaalid = { 'hapnik' , 'CO' } ;

cout << 'Tegelikud kemikaalid:' << endl ;

jaoks ( int i = 0 ; i < kemikaalid. suurus ( ) ; i ++ )

cout << kemikaalid [ i ] << endl ;

// Sisesta element esimesse kohta

kemikaalid. asukoht ( alustada ( kemikaalid ) , 'Mangaan' ) ;

// Sisestage element viimasele positsioonile

kemikaalid. asukoht ( lõpp ( kemikaalid ) , 'Vask' ) ;

// Sisestage element kolmandale kohale

kemikaalid. asukoht ( alustada ( kemikaalid ) + 2 , 'Väävel' ) ;

cout << ' \n Lõplikud kemikaalid:' << endl ;

jaoks ( int i = 0 ; i < kemikaalid. suurus ( ) ; i ++ )

cout << kemikaalid [ i ] << endl ;

}

Väljund:

Nüüd sisaldab viimane vektor viit elementi (esitatud järgmisel ekraanipildil).

Laiendage vektorit kasutades Emplace_Back()

Elemendi saab lisada (liides vektori lõppu), mida saab teha kasutades vektor::emplace_back() funktsiooni.

Süntaks:

vektor. emplace_back ( element )

Vektorile lisatava elemendi edastamine parameetrina on kohustuslik.

Lisame kaks elementi üksteise järel, kasutades funktsiooni emplace_back().

#include

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – kemikaalid

vektor < string > kemikaalid = { 'hapnik' , 'CO' } ;

cout << 'Tegelikud kemikaalid:' << endl ;

jaoks ( int i = 0 ; i < kemikaalid. suurus ( ) ; i ++ )

cout << kemikaalid [ i ] << endl ;

// Mangaani lisamine vektori lõppu

kemikaalid. emplace_back ( 'Mangaan' ) ;

// Mangaani lisamine vektori lõppu

kemikaalid. emplace_back ( 'Vask' ) ;

cout << ' \n Lõplikud kemikaalid:' << endl ;

jaoks ( int i = 0 ; i < kemikaalid. suurus ( ) ; i ++ )

cout << kemikaalid [ i ] << endl ;

}

Väljund:

Nüüd sisaldab viimane vektor neli elementi pärast 'mangaani' ja 'vase' lisamist.

Vektori maksimaalne element

Looge vektor mõne elemendiga.
Vektoris esineva maksimaalse elemendi leidmiseks kasutage funktsiooni *max_element(), mis aktsepteerib argumentidena kahte iteraatorit. Need kaks parameetrit toimivad vahemikuna ja maksimaalne element tagastatakse antud vahemikus. Algpositsioon on begin() ja viimane positsioon on end().

* max_element ( esimene_indeks, viimane_indeks )

Vaatleme vektorit nimega 'item_costs', mis sisaldab viit täisarvu tüüpi väärtust ja tagastab maksimaalse elemendi.

#include

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – kauba_kulud

vektor < int > kauba_kulud = { 8900 , 5677 , 200 , 1000 , 2300 } ;

cout << 'Kaubade maksumus: \n ' ;

jaoks ( int i = 0 ; i < kauba_kulud. suurus ( ) ; i ++ )

cout << kauba_kulud [ i ] << endl ;

// Tagastab maksimaalse elemendi ülaltoodud vektorist - item_costs

cout << ' \n Maksimaalne kulu: ' << * max_element ( alustada ( kauba_kulud ) ,lõpp ( kauba_kulud ) ) ;

}

Väljund:

Siin on 8900 maksimaalne element kõigi vektoris 'item_costs' olevate elementide hulgas.

Vektori minimaalne element

Looge vektor mõne elemendiga.
Vektoris esineva minimaalse elemendi leidmiseks kasutage funktsiooni *min_element(), mis aktsepteerib argumentidena kahte iteraatorit. Need kaks parameetrit toimivad vahemikuna ja minimaalne element (vähem kui kõik teised elemendid) tagastatakse antud vahemikus. Algpositsioon on begin() ja viimane positsioon on end().

* min_element ( esimene_indeks, viimane_indeks )

Kasutage sama vektorit, mis on loodud maksimaalse elemendi leidmiseks ja minimaalse elemendi leidmiseks funktsiooni *min_element() abil.

#include

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – kauba_kulud

vektor < int > kauba_kulud = { 8900 , 5677 , 200 , 1000 , 2300 } ;

cout << 'Kaubade maksumus: \n ' ;

jaoks ( int i = 0 ; i < kauba_kulud. suurus ( ) ; i ++ )

cout << kauba_kulud [ i ] << endl ;

// Tagastab ülaltoodud vektorist minimaalse elemendi - item_costs

cout << ' \n Minimaalne kulu: ' << * min_element ( alustada ( kauba_kulud ) ,lõpp ( kauba_kulud ) ) ;

}

Väljund:

Siin on 200 minimaalne element kõigi vektoris „item_costs” olevate elementide hulgas.

Elementide summa vektoris

Kõigi vektoris esinevate elementide summa tagastamiseks koguma () funktsiooni kasutatakse C++ STL-is. See aktsepteerib kolme parameetrit. Esimene parameeter võtab esimese indeksi, mis tähistab vahemiku alguselementi (määrake algus() iteraator) ja teine parameeter võtab viimase indeksi, mis tähistab vahemiku lõpuelementi (määrake end() iteraator) . Lõpuks peame edastama summa algväärtuse (meie puhul on see 0).

koguneda ( esimene_indeks, viimane_indeks, esialgne_väärtus ) ;

Looge viie täisarvu tüüpi elemendiga vektor nimega 'item_costs' ja arvutage summa.

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – kauba_kulud

vektor < int > kauba_kulud = { 8900 , 5677 , 200 , 1000 , 2300 } ;

cout << 'Kaubade maksumus: \n ' ;

jaoks ( int i = 0 ; i < kauba_kulud. suurus ( ) ; i ++ )

cout << kauba_kulud [ i ] << endl ;

// Tagastab kõigi ülaltoodud vektori elementide summa - item_costs

cout << ' \n Kogumaksumus: ' << koguneda ( alustada ( kauba_kulud ) ,lõpp ( kauba_kulud ) , 0 ) ;

}

Väljund:

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

Kahe vektori elemendipõhine korrutamine

Loo kaks numbrilise tüübiga vektorit ja kaks vektorit peavad olema ühesuurused (esimeses vektoris olevate elementide koguarv = teises vektoris esinevate elementide koguarv).
Deklareerige uus vektor ja kasutage silmuse jaoks , sooritage igas iteratsioonis kahe elemendiga korrutamisoperatsioon ja salvestage väärtus loodud vektorisse, kasutades funktsiooni push_back().

jaoks

(

int

;

suurus

(

)

;

)

{

lükka tagasi

(

[

]

[

]

)

;

}

Kuvage resultantvektoris esinevad elemendid seda itereerides.

Looge viie täisarvu tüüpi elemendiga vektor nimega 'item_costs' ja arvutage summa.

#include

kasutades nimeruum std ;

peamine ( )

{

// Looge kaks vektorit – korrutis1 ja korrutis2, kumbki 5 elemendiga

vektor < int > tooted 1 = { 10 , kakskümmend , 30 , 40 , viiskümmend } ;

vektor < int > tooted 2 = { viiskümmend , 40 , 30 , 70 , 60 } ;

vektor < int > result_products ;

// Sooritage elementaarne korrutamine

jaoks ( int i = 0 ; i < tooted 1. suurus ( ) ; i ++ ) {

result_products. lükka tagasi ( tooted 1 [ i ] * tooted 2 [ i ] ) ;

}

// Kuvab resultantvektori

cout << 'Vektori korrutamine: \n ' ;

jaoks ( int res : result_products )

cout << res << endl ;

}

Väljund:

Iteratsioon - 1 : 10 * viiskümmend => 500

Iteratsioon - 2 : kakskümmend * 40 => 800

Iteratsioon - 3 : 30 * 30 => 900

Iteratsioon - 4 : 40 * 70 => 2800

Iteratsioon - 5 : viiskümmend * 60 => 3000

Kahe vektori punktkorrutis

C++ vektorite puhul defineeritakse punktkorrutis 'kahe vektorijada vastavate kirjete korrutiste summana'.

Süntaks:

sisemine_toode ( Vektor1 esimene, Vektor1 viimane, Vektor2 esimene, Algne_val )

Kasutage punktitoote tagastamiseks funktsiooni inner_product(). See funktsioon võtab neli nõutavat parameetrit.

Siin:

Esimene parameeter viitab iteraatorile, mis osutab esimese vektori algusesse (täpsustage funktsiooni begin() abil).
Teine parameeter viitab iteraatorile, mis osutab esimese vektori lõpule (täpsustage end() funktsiooniga).
Kolmas parameeter viitab iteraatorile, mis osutab teise vektori algusesse (täpsustage funktsiooni begin() abil).
Algväärtus tuleb edastada viimase parameetrina, mis on punktkorrutise kogumise täisarv.

Kasutage sama programmi, mis on loodud kahe vektori korrutamiseks, ja kasutage funktsiooni innsr_product() kahe vektori punktkorrutise leidmiseks.

#include

kasutades nimeruum std ;

peamine ( )

{

// Looge kaks vektorit – korrutis1 ja korrutis2, kumbki 5 elemendiga

vektor < int > tooted 1 = { 10 , kakskümmend , 30 , 40 , viiskümmend } ;

vektor < int > tooted 2 = { viiskümmend , 40 , 30 , 70 , 60 } ;

// Kuvab resultantvektori

cout << 'Toodete1 ja toodete 2 punktkorrutis:' ;

cout << sisemine_toode ( alustada ( tooted 1 ) ,lõpp ( tooted 1 ) , alusta ( tooted 2 ) , 0 ) ;

}

Väljund:

( 10 * viiskümmend ) + ( kakskümmend * 40 ) + ( 30 * 30 ) + ( 40 * 70 ) + ( viiskümmend * 60 )

=> 500 + 800 + 900 + 2800 + 3000

=> 8000

Teisendage komplekt vektoriks

Hulgi teisendamiseks vektoriks on mitmeid viise, edastades kõik komplektis tõstetud elemendid vektorisse. Parim ja lihtsaim viis on kasutada funktsiooni std::copy().

Süntaks

std :: kopeerida ( SourceIterator esimene, sourceIterator viimane, destinationIterator esimene )

Kasuta std::copy() funktsioon, mis lisab hulga elemendid vektorisse. See võtab kolm parameetrit.

Siin:

Esimene parameeter viitab lähteiteraatorile, mis osutab iteraatori esimesele elemendile. Siin on set lähteiteraator, mis määratakse funktsiooni begin() abil.
Samamoodi osutab teine parameeter viimasele elemendile (funktsioon end()).
Kolmas parameeter viitab sihtkoha iteraatorile, mis osutab iteraatori esimesele elemendile (määratud funktsiooni begin() abil).

Loome viie õpilasega komplekti ja kopeerime kõik elemendid eelmise funktsiooni abil vektorisse.

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo komplekt – õpilased 5 elemendiga

seatud < string > õpilased = { 'Sravan' , 'Bobby' , 'Madhu' , 'Meghana' , 'Lavanya' } ;

cout << 'Seadista: \n ' ;

jaoks ( string i : õpilased )

cout << i << endl ;

// Loo vektor – student_vcof suurus võrdub komplekti suurusega

vektor < string > õpilane_vc ( õpilased. suurus ( ) ) ;

// Sisesta elemendid komplektist - õpilased vektorisse - õpilane_vc.

kopeerida ( õpilased. alustada ( ) , õpilased. lõpp ( ) , üliõpilane_vc. alustada ( ) ) ;

cout << ' \n Vektor: \n ' ;

jaoks ( string i : õpilane_vc )

cout << i << endl ;

}

Väljund:

Nüüd kopeeritakse kõik elemendid, mis on komplektis „Õpilased”, vektorisse „students_vc”.

Eemaldage dubleerivad elemendid

Esiteks peame vektori elemendid sorteerima nii, et kõik duplikaatelemendid oleksid üksteise kõrval, kasutades std::sort() funktsiooni.

sorteerida

(

)

;

Kasutage funktsiooni std::unique(), et valida dubleerivad elemendid. Samal ajal kasutage funktsiooni erase() funktsiooni std::unique() tagastatud duplikaatide eemaldamiseks. Elementide järjekord võib lõppvektoris muutuda.

kustutada

(

ainulaadne

(

)

Looge 10 elemendiga vektor 'õpilased' ja tagastage vektor, eemaldades duplikaadid.

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor – õpilased 10 elemendiga

vektor < string > õpilased = { 'Sravan' , 'Bobby' , 'Madhu' , 'Meghana' , 'Lavanya' ,

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

cout << 'Õpilased: \n ' ;

jaoks ( string i : õpilased )

cout << i << ' ' ;

// Sordi kõik elemendid õpilaste vektoris.

sorteerida ( alustada ( õpilased ) , lõpp ( õpilased ) ) ;

// Kasutage unikaalset () funktsiooni, et eemaldada duplikaadid funktsiooniga erase().

õpilased. kustutada ( ainulaadne ( alustada ( õpilased ) , lõpp ( õpilased ) ) , lõpp ( õpilased ) ) ;

cout << ' \n \n Unikaalsed õpilased: \n ' ;

jaoks ( auto itr = cbegin ( õpilased ) ; itr ! = mõni ( õpilased ) ; ++ itr ) {

cout << * itr << ' ' ;

}

}

Väljund:

Nüüd on kõik elemendid vektoris ainulaadsed.

Teisendage vektor komplektiks

Määra ei luba dubleerivaid elemente. Kui sisestate vektori sisestamiseks duplikaatide komplekti, ignoreeritakse neid. Kasutame sama funktsiooni std::copy(), mida kasutati eelmises stsenaariumis, mis teisendas komplekti vektoriks.

Selle stsenaariumi korral:

Esimene parameeter võtab lähteiteraatoriks vektori, mis määratakse funktsiooni begin() abil.
Teine parameeter võtab vektori lähteiteraatoriks, mis määratakse funktsiooni end() abil.
Edastage funktsioon std::inserter(), mida kasutatakse elementide automaatseks ülekirjutamiseks/kopeerimiseks komplektis kindlas kohas, pakkudes parameetritena komplekti ja iteraatorit, mis osutavad komplekti lõppu.

Loome 10 täisarvuga vektori ja kopeerime elemendid hulka.

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo komplekt – märgid 10 väärtusega

vektor < int > märgid = { 12 , 3. 4 , 56 , 78 , 65 , 78 , 90 , 90 , 78 , 3. 4 } ;

cout << 'Vektor: \n ' ;

jaoks ( int i : märgid )

cout << i << ' ' ;

// Loo komplekt - marks_set, mille suurus on võrdne vektori suurusega

seatud < int > marks_set ;

// Sisesta elemendid komplektist - õpilased vektorisse - õpilane_vc.

kopeerida ( alustada ( märgid ) ,lõpp ( märgid ) , sisestaja ( marks_set,end ( marks_set ) ) ) ;

cout << ' \n \n Määra: \n ' ;

jaoks ( int i : marks_set )

cout << i << ' ' ;

}

Väljund:

Olemasoleval vektoril nimega 'märgid' on 10 väärtust. Pärast selle kopeerimist komplekti 'marks_set' sisaldab see ainult kuus elementi, kuna ülejäänud neli elementi on dubleeritud.

Eemaldage tühjad stringid

Tühjadest stringidest, mis vektoris esinevad, pole kasu. Hea tava on eemaldada vektoris olevad tühjad stringid. Vaatame, kuidas eemaldada tühjad stringid C++ vektorist:

Itereerige vektorit 'for' tsükli abil.
Igas iteratsioonis kontrollige, kas element on tühi ('') või ei kasutata operaatorit '==' koos liikmefunktsiooniga at().
Funktsiooni std::erase() abil eemaldage tühjad stringid pärast eelmise tingimuse kontrollimist.
Korrake samme 2 ja 3 kuni vektori lõpuni.

Loome 10 stringiga vektori 'ettevõtted'. Nende hulgas on viis tühjad ja eemaldame need, rakendades eelmist lähenemisviisi.

#include

#include

kasutades nimeruum std ;

peamine ( ) {

vektor < string > ettevõtted { 'Ettevõte A' , '' , 'Ettevõte-B' ,

'' , 'Ettevõte-C' , '' , 'Ettevõte-D' , '' , '' , '' } ;

// Korda ettevõtete üle

// ja eemaldage tühjad elemendid kasutades erase ()

jaoks ( int itr = 1 ; itr < ettevõtted. suurus ( ) ; ++ itr ) {

kui ( ettevõtted. juures ( itr ) == '' ) {

ettevõtted. kustutada ( ettevõtted. alustada ( ) + itr ) ;

-- itr ;

}
}

// Vektori kuvamine

jaoks ( auto & i : ettevõtted ) {

cout << i << endl ;

}

}

Väljund:

Nüüd hoiab 'ettevõtete' vektor mittetühi stringe.

Kirjutage tekstifaili vektor

Arutame, kuidas kirjutada kõik vektoris olevad elemendid faili, kasutades vektorindekseid kasutades fstream .

Lükake mõned elemendid sellesse, kasutades funktsiooni push_back pärast vektori lähtestamist.
Kasutage 'fstream' teegi funktsiooni open() režiimiga out.
Läbige kõik vektoris olevad elemendid, kasutades indekseid 'for' tsüklis ja kirjutage iga element etteantud faili.
Lõpuks sulgege fail.

Rakendame eelmist lähenemisviisi, käivitades C++ koodi.

#include

#include

#include

#include

kasutades nimeruum std ;

peamine ( )

{

// Loo vektor - v_data

// ja suruge sinna kaks elementi.

vektor < string > v_andmed ;

v_andmed. lükka tagasi ( 'Tere tulemast' ) ;

v_andmed. lükka tagasi ( 'LinuxHintile' ) ;

oja f ;

// Avage fail

f. avatud ( 'kirjutatud_fail.txt' ,ios_base :: välja ) ;

// Itereerige vektori iga elementi ja kirjutage faili ükshaaval.

jaoks ( int i = 0 ; i < v_andmed. suurus ( ) ; i ++ )

{

f << v_andmed [ i ] << endl ;

}

// Sule fail

f. Sulge ( ) ;

}

Väljund:

Vektor 'v_data' sisaldab kahte elementi ja faili luuakse teele, kus programm käivitatakse vektoris esinevate elementidega.

Looge tekstifailist vektor

Õppisime, kuidas vektoris esinevaid elemente tekstifaili kirjutada. Loome siin tekstifailis olevast sisust vektori.

Looge ' ifstream” muutuja, mida kasutatakse teabe lugemiseks tekstifailist, milles me failist vektori loome.
Looge faili sisu salvestamiseks tühi vektor ja kasutage faili lõpu kontrollimiseks lipuna tühja stringi muutujat.
Lugege failist järgmist rida, kuni see jõuab lõpuni (põhimõtteliselt kasutades tsüklit 'while'). Kasutage funktsiooni push_back(), et lugeda järgmine rida ja lükata see vektorisse.
Konsooli vektoris esinevate elementide nägemiseks kuvage real esinev rida eraldi.

Rakendame eelmist lähenemisviisi, käivitades C++ koodi. Vaatleme järgmise sisuga faili „data.txt”. Siin on vektori nimi 'v_data'.

#include

kasutades nimeruum std ;

peamine ( )

{

// Ava tekstifail - andmed
ifstream fail ( 'data.txt' ) ;

// Loo vektor - v_data tüübiga - string

vektor < string > v_andmed ;

string oli ;

// Loe failist data.txt järgmine rida
// kuni jõuab lõpuni.

samal ajal ( faili >> oli ) {

// Lugege järgmist rida ja sisestage v_data

v_andmed. lükka tagasi ( oli ) ;

}

// Kuvab real oleva rea eraldi.

kopeerida ( v_andmed. alustada ( ) , v_data. lõpp ( ) , ostream_iterator < string > ( cout , ' \n ' ) ) ;

}

Väljund:

Näeme, et 'v_data' sisaldab viit failist pärit elementi.

Järeldus

Selles pikas artiklis uurisime kõiki võimalikke näiteid, mida kasutatakse C++ programmeerimiskeele vektoritega seotud reaalajas rakendustes. Iga näidet selgitatakse süntaksi, parameetrite ja väljundiga. Koodi selgeks mõistmiseks lisatakse igale koodile kommentaarid.