30 C++ vektorių pavyzdžių

30 C Vektoriu Pavyzdziu



C++ kalboje Vector yra vienmatė duomenų struktūra, kuri dinamiškai didėja pagal poreikį. Duomenų tvarkymas (įterpimas/keitimas/trynimas) šioje duomenų struktūroje gali būti atliktas efektyviai. Jo programos apima šias:

  1. Matematinių vektorių vaizdavimas mokslinėse ir inžinerinėse programose
  2. Naudojant šią duomenų struktūrą gali būti įdiegtos eilės, krūvos ir kt.

Dauguma įprastų CRUD operacijų ir funkcijų, susijusių su šia duomenų struktūra, yra išsamiai aptariamos pagal scenarijų, naudojant sintaksę ir kodo fragmentus.







Turinio tema:

  1. Įterpti elementą į vektorių
  2. Įterpti kelis elementus į vektorių
  3. Pasiekite elementus iš vektoriaus
  4. Atnaujinkite elementą vektoriuje
  5. Pašalinkite konkretų elementą iš vektoriaus
  6. Pašalinkite visus elementus iš vektoriaus
  7. Vektorių sąjunga
  8. Vektorių sankirta
  9. Patikrinkite, ar vektorius tuščias, ar ne
  10. Pereikite vektorių naudodami Const_Iterator
  11. Pereikite vektorių naudodami Reverse_Iterator
  12. Įstumkite elementus į vektorių
  13. Išskleiskite elementus iš vektoriaus
  14. Sukeiskite vektorius
  15. Paimkite pirmąjį elementą iš vektoriaus
  16. Paimkite paskutinį elementą iš vektoriaus
  17. Priskirkite vektoriui naujų reikšmių
  18. Išplėskite vektorių naudodami Emplace ()
  19. Išplėskite vektorių naudodami Emplace_Back()
  20. Maksimalus vektoriaus elementas
  21. Minimalus vektoriaus elementas
  22. Elementų suma vektoriuje
  23. Dviejų vektorių daugyba pagal elementus
  24. Dviejų vektorių taškinė sandauga
  25. Konvertuokite rinkinį į vektorių
  26. Pašalinkite pasikartojančius elementus
  27. Paverskite vektorių į rinkinį
  28. Pašalinkite tuščias eilutes
  29. Į tekstinį failą įrašykite vektorių
  30. Sukurkite vektorių iš tekstinio failo

Įterpti elementą į vektorių

The std::vector::insert() Funkcija C++ STL naudojama elementams įterpti nurodytoje vietoje.



Sintaksė:

vektorius. Įdėti ( padėtis, elementas ) ;

Panaudokime šią funkciją ir pirmąją poziciją perduokime kaip parametrą, nurodantį vietą, kurioje elementas turi būti įterptas, ir nurodykime elementą kaip antrąjį parametrą.



Funkcija begin() gali būti panaudota čia norint grąžinti iteratorių, nukreipiantį į pirmąjį įvesties vektoriaus elementą. Pridėjus poziciją prie šios funkcijos, elementas įterpiamas į tą vietą.





Sukurkime tipo string vektorių „studentų_vardai“ ir įterpkime dvi eilutes pirmoje ir antroje pozicijose vieną po kitos, naudodami funkciją insert().

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Vektoriaus inicijavimas - studentų_vardai

vektorius < styga > studentų_vardai ;

cout << 'Esamas vektorius: \n ;

dėl ( automatinis i : studentų_vardai ) cout << i << endl ;

// Pirmoje vietoje įterpti 'Sravan Kumar'.

studentų_vardai. Įdėti ( studentų_vardai. pradėti ( ) + 0 , 'Shravan Kumar' ) ;

// Antroje vietoje įterpti 'Sravan Kumar'.

studentų_vardai. Įdėti ( studentų_vardai. pradėti ( ) + 1 , 'Lalitha' ) ;

cout << 'Galutinis vektorius: \n ;

dėl ( automatinis j : studentų_vardai ) cout << j << endl ;

}

Išvestis:

Anksčiau vektorius „studentų_vardai“ buvo tuščias. Po įterpimo vektorius turi du elementus.



Į vektorių įterpti kelis elementus

Šiame scenarijuje naudojame tą pačią funkciją, kuri yra std::vector::insert(). Bet mes turime perduoti papildomus / skirtingus parametrus tai pačiai funkcijai, kad į vektorių įterptume kelis elementus.

1 scenarijus: Vieno elemento įterpimas kelis kartus

Pagal šį scenarijų tą patį elementą pridedame kelis kartus.

Sintaksė:

vektorius. Įdėti ( padėtis, dydis, elementas ) ;

Norėdami tai padaryti, turime perduoti dydį kaip antrąjį parametrą funkcijai insert(). Iš viso šiai funkcijai perduodami trys parametrai.

Čia:

  1. Padėties parametras nurodo elemento padėtį, kurią reikia įterpti. Jei dydis yra didesnis nei 1, pradinės padėties indeksas bus pozicija.
  2. Dydžio parametras nurodo, kiek kartų elementas turi būti įterptas.
  3. Elemento parametras paima elementą, kuris turi būti įterptas į vektorių.

Apsvarstykite vektorių „studentų_pavadinimai“ su dviem eilutėmis. Penkis kartus įkiškite „Lavanya“ eilutes antroje vietoje.

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Vektoriaus inicijavimas - studentų_vardai

vektorius < styga > studentų_vardai { 'Shravan Kumar' , 'Lalitha' } ;

cout << 'Esamas vektorius: \n ;

dėl ( automatinis i : studentų_vardai ) cout << i << endl ;

// Įterpti „Lavanya“ antroje vietoje 5 kartus

studentų_vardai. Įdėti ( studentų_vardai. pradėti ( ) + 1 , 5 , 'Lavanija' ) ;

cout << \n Galutinis vektorius: \n ;

dėl ( automatinis j : studentų_vardai ) cout << j << endl ;

}

Išvestis:

Esamame vektoriuje „Sravan Kumar“ yra pirmoje pozicijoje, o „Lalitha“ yra antroje pozicijoje. Penkis kartus įdėjus „Lavanya“ (iš antros pozicijos į šeštą), „Lalitha“ pakilo į septintą (paskutinę).

2 scenarijus: kelių elementų įterpimas

Pagal šį scenarijų vienu metu pridedame skirtingus elementus iš kito vektoriaus. Čia taip pat naudojame tą pačią funkciją, tačiau pasikeis sintaksė ir parametrai.

Sintaksė:

vektorius. Įdėti ( pozicija, pirmasis_iteratorius, antrasis_iteratorius ) ;

Norėdami tai padaryti, turime perduoti dydį kaip antrąjį parametrą funkcijai insert(). Iš viso šiai funkcijai perduodami trys parametrai.

Čia:

  1. Padėties parametras nurodo elemento padėtį, kurią reikia įterpti.
  2. „First_iterator“ nurodo pradinę padėtį, iš kurios turi būti įterpiami elementai (iš esmės, naudojant start() funkciją, grąžinamas iteratorius, nukreipiantis į pirmąjį konteineryje esantį elementą).
  3. „Second_iterator“ nurodo pabaigos vietą, iki kurios turi būti įterpiami elementai (iš esmės, naudojant end() funkciją, grąžinamas iteratorius, nukreipiantis šalia paskutinio konteinerio taško).

Sukurkite du sveikojo skaičiaus vektorius „marks1“ ir „marks2“. Įdėkite visus elementus, esančius vektoriuje „marks2“ į pirmąją „marks1“ vektoriaus padėtį.

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Vektoriaus inicijavimas - marks1

vektorius < tarpt > pažymiai1 { 100 , 89 , 90 , 78 , 98 } ;

cout << 'Pirmasis vektorius: \n ;

dėl ( automatinis i : pažymiai1 ) cout << i << endl ;

// Vektoriaus inicijavimas - marks2

vektorius < tarpt > pažymiai2 { 56 , Keturi. Penki , 65 } ;

cout << 'Antras vektorius: \n ;

dėl ( automatinis j : pažymiai2 ) cout << j << endl ;

pažymiai1. Įdėti ( pradėti ( pažymiai1 ) , pradėti ( pažymiai2 ) , galas ( pažymiai2 ) ) ;



// Galutinis vektorius

cout << 'Pirmasis galutinis vektorius: \n ;

dėl ( automatinis x : pažymiai1 )

cout << x << ' ' ;

}

Išvestis:

Pirmasis vektorius (marks1) turi penkis elementus, o antrasis vektorius (marks2) turi tris elementus. Parametrus pradžia (marks1), begin (marks2), end (marks2) perdavėme funkcijai „įterpti“, kad visi elementai, esantys antrajame vektoriuje, būtų kartojami ir pradžioje įterpiami į pirmąjį vektorių. Taigi pirmasis vektorius turi aštuonis elementus.

Pasiekite elementus iš vektoriaus

1. Naudodami [] operatorių

Kai kuriais atvejais gali būti reikalaujama iš vektoriaus grąžinti tik konkrečius elementus. Visų elementų grąžinti nereikia. Taigi, norint grąžinti tik konkrečius elementus, pagrįstus indeksu, naudojamas indekso operatorius ir at() funkcijos.

Sintaksė:

vektorius [ indekso_pozicija ]

C++ bet kokios duomenų struktūros indeksavimas prasideda nuo 0. Jei elemento nėra, jis grąžinamas tuščias (nėra klaidos arba nerodomas įspėjimas).

Apsvarstykite „produktų“ vektorių su penkiais elementais. Pasiekite visus elementus po vieną naudodami rodyklės padėtį.

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – produktai su 5 eilutėmis

vektorius < styga > Produktai { 'muilas' , 'šampūnas' , 'Alyva' , 'vaisiai' , 'daržovės' } ;

//Prieiga prie elementų iš produktų

cout << „Pirmasis elementas:“ << Produktai [ 0 ] << endl ;

cout << 'Antrasis elementas:' << Produktai [ 1 ] << endl ;

cout << 'Trečias elementas:' << Produktai [ 2 ] << endl ;

cout << 'Ketvirtasis elementas:' << Produktai [ 3 ] << endl ;

cout << 'Penktasis elementas:' << Produktai [ 4 ] << endl ;



// Pabandykite pasiekti 9-ąjį elementą

cout << „Devintasis elementas:“ << Produktai [ 8 ] << endl ;

}

Išvestis:

Rodyklėje 8 nėra elemento. Taigi, grąžinamas tuščias.

2. Funkcijos At() naudojimas

At() yra nario funkcija, panaši į ankstesnį naudojimo atvejį, tačiau ji grąžina išimtį „std::out_of_range“, kai jai pateikiamas indeksas už diapazono ribų.

Sintaksė:

vektorius. adresu ( indekso_pozicija )

Šiai funkcijai turime perduoti indekso poziciją.

Apsvarstykite „produktų“ vektorių su penkiais elementais. Pasiekite visus elementus po vieną naudodami rodyklės poziciją ir pabandykite pasiekti elementą, esantį 9 pozicijoje.

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – produktai su 5 eilutėmis

vektorius < styga > Produktai { 'muilas' , 'šampūnas' , 'Alyva' , 'vaisiai' , 'daržovės' } ;

//Prieiga prie elementų iš produktų

cout << „Pirmasis elementas:“ << Produktai. adresu ( 0 ) << endl ;

cout << 'Antrasis elementas:' << Produktai. adresu ( 1 ) << endl ;

cout << 'Trečias elementas:' << Produktai. adresu ( 2 ) << endl ;

cout << 'Ketvirtasis elementas:' << Produktai. adresu ( 3 ) << endl ;

cout << 'Penktasis elementas:' << Produktai. adresu ( 4 ) << endl ;



//Prieiga prie elementų, kurie nėra vektoriuje

cout << „Devintasis elementas:“ << Produktai. adresu ( 8 ) << endl ;

}

Išvestis:

Prieinant prie 9 elemento įvyko klaida:

terminate iškviestas išmetus egzempliorių 'std::out_of_range'

( ) : vektorius :: _M_diapazono_čekis : __n ( kuris yra 8 ) >= tai - > dydis ( ) ( kuris yra 5 )

Atnaujinkite elementą vektoryje

1. Naudodami [] operatorių

Naudodamiesi rodyklės padėtimi, galime atnaujinti elementą vektoriuje. Operatorius [] užima elemento, kurį reikia atnaujinti, indekso poziciją. Naujas elementas bus priskirtas šiam operatoriui.

Sintaksė:

Vektorius [ indekso_pozicija ] = Elementas

Apsvarstykite vektorių „student_marks“ su penkiomis reikšmėmis. Atnaujinkite elementus, esančius 1 ir 3 indeksuose.

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – studentų_ženklai

vektorius < tarpt > studentų_ženklai { 98 , 78 , 90 , 67 , 89 } ;

cout << 'Esami ženklai:' << endl ;

dėl ( tarpt itr : studentų_ženklai )

cout << itr << endl ;

// Atnaujinkite elementą indekse-3 su 100

studentų_ženklai [ 3 ] = 100 ;

// Atnaujinkite elementą indekse-1 su 60

studentų_ženklai [ 1 ] = 60 ;

cout << 'Galutinės pažymos:' << endl ;

dėl ( tarpt itr : studentų_ženklai )

cout << itr << endl ;

}

Išvestis:

Matome, kad galutinis vektorius turi atnaujinimo elementus 1 ir 3 indeksuose.

2. Funkcijos At() naudojimas

Panašiai kaip ir indekso operatorius, at() iš esmės yra nario funkcija, kuri atnaujina reikšmę pagal iteratoriaus indeksą. Jei indeksas, nurodytas šioje funkcijoje, neegzistuoja, išmeta „std::out_of_range“ išimtis.

vektorius. adresu ( indekso_pozicija ) = Elementas

Apsvarstykite „produktų“ vektorių su penkiais elementais. Atnaujinkite visus vektoriaus elementus su kitais elementais.

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – produktai su 5 eilutėmis

vektorius < styga > Produktai { 'muilas' , 'šampūnas' , 'Alyva' , 'vaisiai' , 'daržovės' } ;

cout << 'Esami produktai:' << endl ;

dėl ( styga itr : Produktai )

cout << itr << endl ;

//Atnaujinamos visos eilutės

Produktai. adresu ( 0 ) = 'Tortas' ;

Produktai. adresu ( 1 ) = 'Šokoladas' ;

Produktai. adresu ( 2 ) = 'Vaisiai' ;

Produktai. adresu ( 3 ) = 'svogūnai' ;

Produktai. adresu ( 4 ) = 'gaivieji gėrimai' ;



cout << \n Galutiniai produktai: ' << endl ;

dėl ( styga itr : Produktai )

cout << itr << endl ;

}

Išvestis:

Pašalinkite konkretų elementą iš vektoriaus

C++ kalboje std::vektorius::trinti() Funkcija naudojama tam tikram elementui / elementų diapazonui pašalinti iš vektoriaus. Elementai pašalinami pagal iteratoriaus pozicijas.

Sintaksė:

vektorius. ištrinti ( iteratoriaus padėtis )

Pažiūrėkime konkretaus elemento pašalinimo iš vektoriaus sintaksę. Galime naudoti start() arba end() funkcijas, kad gautume pašalinamo vektoriaus elemento padėtį.

Apsvarstykite „produktų“ vektorių su penkiais elementais.

  1. Pašalinkite trečiąjį elementą nurodydami start() iteratorių. Begin() nurodo pirmąjį vektoriaus elementą. Jei prie šios funkcijos pridedame du, jis nurodo trečiąjį elementą.
  2. Pašalinkite paskutinį elementą nurodydami end() iteratorių. End() nurodo paskutinį vektoriaus elementą.
#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – produktai su 5 eilutėmis

vektorius < styga > Produktai { 'muilas' , 'šampūnas' , 'Alyva' , 'vaisiai' , 'daržovės' } ;

cout << 'Esami produktai:' << endl ;

dėl ( styga itr : Produktai )

cout << itr << endl ;



// Pašalinti 3 elementą

Produktai. ištrinti ( Produktai. pradėti ( ) + 2 ) ;

cout << \n Pašalinus 3 elementą: \n ;

dėl ( styga itr : Produktai )

cout << itr << endl ;

// Pašalinti paskutinį elementą

Produktai. ištrinti ( Produktai. galas ( ) ) ;

cout << \n Pašalinus paskutinį elementą: \n ;

dėl ( styga itr : Produktai )

cout << itr << endl ;

}

Išvestis:

Dabar „produktų“ vektoriuje yra tik trys elementai („muilas“, „šampūnas“, „vaisiai“).

Pašalinkite visus elementus iš vektoriaus

1 scenarijus: pašalinkite elementų diapazoną iš vektoriaus

Norėdami pašalinti kelis diapazono elementus, naudokite funkciją std::vector::erase().

Sintaksė:

vektorius. ištrinti ( pirmas iteratorius, paskutinis iteratorius )

Du iteratoriai (begin() nurodo pirmąjį elementą ir end() nurodo paskutinio elemento funkcijas) naudojami diapazonui nurodyti.

Apsvarstykite „produktų“ vektorių su penkiais elementais ir pašalinkite visus elementus iš antrosios padėties. Norint tai pasiekti, pirmasis iteratorius yra pradžia (produktai)+1, nukreipiantis į antrąjį elementą, o antrasis iteratorius yra pabaiga (produktai).

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – produktai su 5 eilutėmis

vektorius < styga > Produktai { 'muilas' , 'šampūnas' , 'Alyva' , 'vaisiai' , 'daržovės' } ;

cout << 'Esami produktai:' << endl ;

dėl ( styga itr : Produktai )

cout << itr << endl ;



// Pašalinkite visus elementus iš antrosios padėties

Produktai. ištrinti ( pradėti ( Produktai ) + 1 ,galas ( Produktai ) ) ;

cout << \n Galutiniai produktai: \n ;

dėl ( styga itr : Produktai )

cout << itr << endl ;

}

Išvestis:

Dabar „produktų“ vektoriuje yra tik vienas elementas („muilas“).

2 scenarijus: pašalinkite visus elementus iš vektoriaus

Pasinaudokime std::vector::clear() funkcija pašalinti visus elementus iš vektoriaus.

Sintaksė:

vektorius. aišku ( )

Šiai funkcijai parametrai neperduodami.

Apsvarstykite tą patį vektorių, kuris buvo naudojamas pirmame scenarijuje, ir pašalinkite visus elementus naudodami funkciją clear().

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – produktai su 5 eilutėmis

vektorius < styga > Produktai { 'muilas' , 'šampūnas' , 'Alyva' , 'vaisiai' , 'daržovės' } ;

cout << 'Esami produktai:' << endl ;

dėl ( styga itr : Produktai )

cout << itr << endl ;



// Pašalinkite visus elementus iš produktų

Produktai. aišku ( ) ;

cout << \n Galutiniai produktai: \n ;

dėl ( styga itr : Produktai )

cout << itr << endl ;

}

Išvestis:

Matome, kad „produktų“ vektoriuje nėra elementų.

Vektorių sąjunga

Galima atlikti UNION operaciją vektoriams naudojant std::set_union() funkciją. Sąjunga grąžina unikalius elementus iš vektorių, nepaisydama pasikartojančių elementų. Šiai funkcijai turime perduoti abu iteratorius. Be to, reikia perduoti išvesties iteratorių, kuris saugo rezultatą, kurį grąžina abu iteratoriai.

Sintaksė:

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

Čia:

  1. „First1“ nurodo pirmąjį pirmojo iteratoriaus elementą (vektorių).
  2. „Last1“ nurodo paskutinį pirmojo iteratoriaus elementą (vektorių).
  3. „First2“ nurodo pirmąjį antrojo iteratoriaus elementą (vektorių).
  4. „Paskutinis2“ nurodo paskutinį antrojo iteratoriaus elementą (vektorių).

Sukurkite du vektorius – „subjects1“ ir „subjects2“ – sveikojo skaičiaus tipo.

  1. Surūšiuokite du vektorius naudodami funkciją sort () perduodant iteratorius.
  2. Sukurkite išvesties vektorių (iteratorių).
  3. Raskite šių dviejų vektorių sąjungą naudodami funkciją std::set_union(). Naudokite begin() kaip pirmąjį iteratorių ir end() kaip paskutinį iteratorių.
  4. Pakartokite išvesties vektorių, kad būtų rodomi elementai, kuriuos grąžina funkcija.
#include

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – žymės1

vektorius < tarpt > pažymiai1 = { 100 , 90 , 80 , 70 , 60 } ;



// Sukurti vektorių - marks2

vektorius < tarpt > pažymiai2 = { 80 , 90 , 60 , 70 , 100 } ;

// Rūšiuoti abu vektorius

rūšiuoti ( pažymiai1. pradėti ( ) , pažymiai1. galas ( ) ) ;

rūšiuoti ( pažymiai2. pradėti ( ) , pažymiai2. galas ( ) ) ;

vektorius < tarpt > išvestiesVektorius ( pažymiai1. dydis ( ) + pažymiai2. dydis ( ) ) ;

vektorius < tarpt > :: iteratorius aš, s ;

i = set_union ( pažymiai1. pradėti ( ) , pažymiai1. galas ( ) ,

pažymiai2. pradėti ( ) ,žymiai2. galas ( ) ,

išvestiesVektorius. pradėti ( ) ) ;

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

dėl ( s = išvestiesvektorius. pradėti ( ) ; s ! = i ; ++ s )

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

}

Išvestis:

Abiejuose vektoriuose (subjektai1 ir subjektai2) yra tik penki unikalūs elementai.

Vektorių sankirta

Rasti dviejų vektorių sankirtą galima naudojant funkciją std::set_intersection(). Sankirta grąžina elementus, esančius abiejuose vektoriuose.

Sintaksė:

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

Parametrai, perduodami funkcijai set_union(), taip pat gali būti perduoti šiai funkcijai set_intersection().

Sukurkite du vektorius – „subjects1“ ir „subjects2“ – sveikojo skaičiaus tipo.

  1. Surūšiuokite du vektorius naudodami funkciją sort () perduodant iteratorius.
  2. Sukurkite išvesties vektorių (iteratorių).
  3. Raskite šių dviejų vektorių sankirtą naudodami funkciją std::set_intersection(). Naudokite begin() kaip pirmąjį iteratorių ir end() kaip paskutinį iteratorių.
  4. Pakartokite išvesties vektorių, kad būtų rodomi elementai, kuriuos grąžina funkcija.
#include

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – žymės1

vektorius < tarpt > pažymiai1 = { 100 , 10 , 80 , 40 , 60 } ;



// Sukurti vektorių - marks2

vektorius < tarpt > pažymiai2 = { penkiasdešimt , 90 , 60 , 10 , 100 } ;

// Rūšiuoti abu vektorius

rūšiuoti ( pažymiai1. pradėti ( ) , pažymiai1. galas ( ) ) ;

rūšiuoti ( pažymiai2. pradėti ( ) , pažymiai2. galas ( ) ) ;

vektorius < tarpt > išvestiesVektorius ( pažymiai1. dydis ( ) + pažymiai2. dydis ( ) ) ;

vektorius < tarpt > :: iteratorius aš, s ;

i = set_intersection ( pažymiai1. pradėti ( ) , pažymiai1. galas ( ) ,

pažymiai2. pradėti ( ) ,žymiai2. galas ( ) ,

išvestiesvektorius. pradėti ( ) ) ;

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

dėl ( s = išvestiesvektorius. pradėti ( ) ; s ! = i ; ++ s )

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

}

Išvestis:

Abiejuose vektoriuose (subjektai1 ir subjektai2) yra tik trys elementai.

Patikrinkite, ar vektorius tuščias, ar ne

Prieš pradedant dirbti su vektoriais, svarbu patikrinti, ar vektorius tuščias, ar ne. Taip pat gera praktika programinės įrangos projektuose yra patikrinti, ar vektorius tuščias, ar ne prieš atliekant tokias operacijas kaip CRUD operacijos ir pan.

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

Ši funkcija grąžina 1, jei vektorius tuščias (jame nėra elemento). Kitu atveju grąžinamas 0. Šiai funkcijai neperduodamas joks parametras.

2. Naudodami Std::vektorius::dydis()

Funkcija std::vector::size() grąžina sveikąjį skaičių, nurodantį bendrą vektoryje esančių elementų skaičių.

Sukurkite du vektorius – „college1“ ir „college2“. „College1“ turi penkis elementus, o „college2“ yra tuščias. Taikykite abi funkcijas abiem vektoriams ir patikrinkite išvestį.

#include

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – koledžas1

vektorius < styga > kolegija1 = { 'A kolegija' , 'B koledžas' , 'koledžas-C' , 'kolegija-D' , 'Kolegija-E' } ;

// Sukurti vektorių – koledžas2

vektorius < styga > kolegija2 ;

// tuščia()

cout << kolegija1. tuščia ( ) << endl ;

cout << kolegija2. tuščia ( ) << endl ;

// dydis ()

cout << kolegija1. dydis ( ) << endl ;

cout << kolegija2. dydis ( ) << endl ;

}

Išvestis:

Funkcija tuščia () grąžina 0 „college1“ ir 1 „college2“. Funkcija size() grąžina penkis „college1“ ir 0 „college2“.

Pereikite vektorių naudodami Const_Iterator

Kai dirbate su C++ konteineriais, tokiais kaip rinkiniai, vektoriai ir pan., galima kartoti visus konteineryje esančius elementus jų nekeičiant. The const_iterator yra vienas iš iteratorių, pasiekiančių šį scenarijų. cbegin() (nurodo į pirmąjį vektoriaus elementą) ir cend() (nurodo į paskutinį vektoriaus elementą) yra dvi funkcijos, kurias teikia kiekvienas konteineris, kuris naudojamas norint grąžinti pastovųjį iteratorių į vektoriaus pradžią ir pabaigą. konteineris. Iteruodami vektorių galime naudoti šias dvi funkcijas.

  1. Sukurkime vektorių pavadinimu „departamentai“ su penkiomis eilutėmis.
  2. Paskelbkite const_iterator – ctr tipo .
  3. Pakartokite skyrius naudodami ankstesnį iteratorių naudodami kilpą „for“ ir parodykite jį.
#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – skyriai

vektorius < styga > skyriai = { 'Pardavimai' , 'Paslauga' ,

'HR' , 'IT' , 'Kiti' } ;



vektorius < styga > :: const_iterator ctr ;

// Pakartokite skyrius naudodami const_iterator - ctr.

dėl ( ctr = skyriai. cbegin ( ) ; ctr ! = skyriai. keletas ( ) ; ctr ++ ) {

cout << * ctr << endl ;

}

}

Išvestis:

Pereikite vektorių naudodami Reverse_Iterator

The atvirkštinis_iteratorius taip pat yra iteratorius, panašus į const_iterator, bet grąžina elementus atvirkščiai. rbegin() (nurodo į paskutinį vektoriaus elementą) ir rend() (nurodo į pirmąjį vektoriaus elementą) yra dvi funkcijos, kurias teikia kiekvienas konteineris, naudojamas norint grąžinti pastovųjį iteratorių į vektoriaus pabaigą ir pradžią. konteineris.

  1. Sukurkime vektorių pavadinimu „departamentai“ su penkiomis eilutėmis.
  2. Paskelbkite reverse_iterator – rtr tipo .
  3. Pakartokite skyrius naudodami ankstesnį iteratorių naudodami kilpą „for“ ir parodykite jį.
#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – skyriai

vektorius < styga > skyriai = { 'Pardavimai' , 'Paslauga' ,

'HR' , 'IT' , 'Kiti' } ;



vektorius < styga > :: atvirkštinis_iteratorius rtr ;

// Pakartokite skyrius naudodami reverse_iterator - rtr.

dėl ( rtr = skyriai. rbegin ( ) ; rtr ! = skyriai. daro ( ) ; rtr ++ ) {

cout << * rtr << endl ;

}

}

Išvestis:

Įstumkite elementus į vektorių

Elementų įterpimas arba įtraukimas į vektorių yra vienpusis įterpimas, kurį galima atlikti naudojant vektorius::push_back() funkcija.

Sintaksė:

vektorius. pastumti atgal ( elementas )

Reikia elemento, kuris turi būti įstumtas į vektorių kaip parametras.

Sukurkime tuščią vektorių pavadinimu „departamentai“ su penkiomis eilutėmis ir stumkime dvi eilutes vieną po kitos naudodami funkciją push_back().

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Inicijuoti vektorių – skyriai

vektorius < styga > skyriai ;

cout << „Tikrieji skyriai:“ << endl ;

dėl ( automatinis itr = skyriai. pradėti ( ) ; itr ! = skyriai. galas ( ) ; ++ itr )

cout << * itr << endl ;

// Paspauskite 'Pardavimas'

skyriai. pastumti atgal ( 'Pardavimai' ) ;

// Paspauskite 'IT'

skyriai. pastumti atgal ( 'IT' ) ;

cout << \n Baigiamieji skyriai:' << endl ;

dėl ( automatinis itr = skyriai. pradėti ( ) ; itr ! = skyriai. galas ( ) ; ++ itr )

cout << * itr << endl ;

}

Išvestis:

Pirmiausia stumiame „Pardavimai“. Po to „IT“ įstumiamas į vektorių. Dabar „skyrių“ vektorius turi du elementus.

Išskleiskite elementus iš vektoriaus

Jei norite ištrinti paskutinį elementą, esantį vektoriuje, naudokite vektorius::pop_back() funkcija yra geriausias būdas. Ištrina paskutinį elementą, esantį vektoriuje.

Sintaksė:

vektorius. pop_back ( )

Šiai funkcijai nereikia jokių parametrų. Tai rodo neapibrėžtą elgesį, jei bandome ištrinti paskutinį elementą iš tuščio vektoriaus.

Sukurkime tuščią vektorių pavadinimu „departamentai“ su penkiomis eilutėmis ir ištrinkite paskutinį elementą naudodami ankstesnę funkciją. Abiem atvejais parodykite vektorių.

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Inicijuoti vektorių – skyriai

vektorius < styga > skyriai = { 'Pardavimai' , 'IT' , 'Paslauga' , 'Rinkodara' , 'HR' } ;

cout << „Tikrieji skyriai:“ << endl ;

dėl ( automatinis itr = skyriai. pradėti ( ) ; itr ! = skyriai. galas ( ) ; ++ itr )

cout << * itr << endl ;



// Ištrinti paskutinį elementą

skyriai. pop_back ( ) ;

cout << \n Baigiamieji skyriai:' << endl ;

dėl ( automatinis itr = skyriai. pradėti ( ) ; itr ! = skyriai. galas ( ) ; ++ itr )

cout << * itr << endl ;

}

Išvestis:

„HR“ yra paskutinis elementas, esantis „departamentų“ vektoriuje. Taigi, jis pašalinamas iš vektoriaus, o galutinis vektorius turi „Pardavimai“, „IT“, „Paslauga“ ir „Rinkodara“.

Sukeiskite vektorius

The vektorius::swap() Funkcija C++ STL naudojama sukeisti visus elementus, esančius dviejuose vektoriuose.

Sintaksė:

pirmasis_vektorius. apsikeisti ( antrasis_vektorius )

Ji neatsižvelgia į vektorių dydį, bet vektoriai turi būti to paties tipo (jei vektorių tipai skiriasi, įvedama klaida).

Sukurkime du skirtingų dydžių eilutės tipo vektorius – „vaisius“ ir „daržoves“. Sukeiskite kiekvieną iš jų ir parodykite vektorius abiem atvejais.

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Inicijuoti vektorių – vaisius

vektorius < styga > vaisiai = { 'Apple' , 'Mango' } ;

cout << „Tikrieji vaisiai:“ << endl ;

dėl ( automatinis itr = vaisiai. pradėti ( ) ; itr ! = vaisiai. galas ( ) ; ++ itr )

cout << * itr << endl ;



// Inicijuoti vektorių – daržoves

vektorius < styga > daržovės = { 'Bulvė' , 'Pomidoras' , 'Brinjal' } ;

cout << \n Tikrosios daržovės:' << endl ;

dėl ( automatinis itr = daržovės. pradėti ( ) ; itr ! = daržovės. galas ( ) ; ++ itr )

cout << * itr << endl ;



// Sukeisti elementus abiejuose vektoriuose

vaisiai. apsikeisti ( daržovės ) ;

cout << \n Vaisiai pakeitus:' << endl ;

dėl ( automatinis itr = vaisiai. pradėti ( ) ; itr ! = vaisiai. galas ( ) ; ++ itr )

cout << * itr << endl ;

cout << \n Daržovės po keitimo:' << endl ;

dėl ( automatinis itr = daržovės. pradėti ( ) ; itr ! = daržovės. galas ( ) ; ++ itr )

cout << * itr << endl ;

}

Išvestis:

Anksčiau „vaisių“ vektorius turi du elementus, o „daržovės“ – tris elementus. Pakeitus, „vaisių“ vektorius turi tris elementus, o „daržovės“ – du elementus.

Paimkite pirmąjį elementą iš vektoriaus

Kai kuriais atvejais reikalaujama grąžinti tik pirmąjį elementą iš vektoriaus. Vektoriaus::front() funkcija C++ STL paima tik pirmąjį elementą iš vektoriaus.

Sintaksė:

vektorius. priekyje ( )

Ši funkcija nepriims jokių parametrų. Jei vektorius tuščias, įvedama klaida.

Sukurkime du vektorius – „vaisius“ ir „daržoves“ – eilutės tipo ir pabandykime paimti pirmąjį elementą atskirai nuo dviejų vektorių.

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – vaisius su 2 elementais

vektorius < styga > vaisiai = { 'Apple' , 'Mango' } ;

// Grąžina pirmąjį elementą

cout << vaisiai. priekyje ( ) << endl ;



// Inicijuoti vektorių – daržoves

vektorius < styga > daržovės ;

// Pabandykite grąžinti pirmąjį elementą

cout << daržovės. priekyje ( ) ;

}

Išvestis:

„Obuolys“ yra pirmasis elementas, esantis „vaisių“ vektoriuje. Taigi, jis grąžinamas. Tačiau bandant paimti pirmąjį elementą iš „daržovių“ vektoriaus, atsiranda klaida, nes jis tuščias.

Paimkite paskutinį elementą iš vektoriaus

Vektoriaus::end() funkcija C++ STL paima tik paskutinį elementą iš vektoriaus.

Sintaksė:

vektorius. atgal ( )

Ši funkcija nepriims jokių parametrų. Jei vektorius tuščias, įvedama klaida.

Sukurkime du vektorius - 'vaisius' ir 'daržoves' - eilutės tipo ir pabandykite gauti paskutinį elementą atskirai nuo dviejų vektorių.

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – vaisius su 2 elementais

vektorius < styga > vaisiai = { 'Apple' , 'Mango' } ;

// Paimkite paskutinį elementą

cout << vaisiai. atgal ( ) << endl ;



// Inicijuoti vektorių – daržoves

vektorius < styga > daržovės ;

// Pabandykite gauti paskutinį elementą

cout << daržovės. atgal ( ) ;

}

Išvestis:

„Mango“ yra paskutinis elementas, esantis „vaisių“ vektoriuje. Taigi, jis grąžinamas. Tačiau bandant paimti paskutinį elementą iš „daržovių“ vektoriaus, atsiranda klaida, nes jis tuščias.

Priskirkite vektoriui naujų reikšmių

Kai kuriais atvejais, jei norite atnaujinti visas reikšmes nauja verte arba sukurti vektorių su tomis pačiomis reikšmėmis, geriausias būdas yra naudoti vektorius::assign() funkciją. Naudodami šią funkciją galime:

  1. Sukurkite vektorių su visais panašiais elementais
  2. Pakeiskite esamą vektorių tuo pačiu elementu

Sintaksė:

vektorius. priskirti ( dydis, vertė )

Šiai funkcijai reikalingi du parametrai.

Čia:

  1. Dydis nurodo elementų, kuriuos reikia priskirti, skaičių.
  2. Reikšmė nurodo elementą, kurį reikia priskirti.

Sukurkime vektorių pavadinimu „marks1“ su penkiomis reikšmėmis ir atnaujinkime šį vektorių keturiais elementais taip, kad visi atnaujinto vektoriaus elementai būtų lygūs 20.

#include

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – žymės1

vektorius < tarpt > pažymiai1 = { 100 , 90 , 80 , 70 , 60 } ;

cout << 'Tikrasis vektorius:' << endl ;

dėl ( tarpt i = 0 ; i < pažymiai1. dydis ( ) ; i ++ )

cout << pažymiai1 [ i ] << endl ;



pažymiai1. priskirti ( 4 , dvidešimt ) ;



cout << \n Atnaujintas vektorius: << endl ;

dėl ( tarpt i = 0 ; i < pažymiai1. dydis ( ) ; i ++ )

cout << pažymiai1 [ i ] << endl ;

}

Išvestis:

Anksčiau vektorius turi penkis skirtingus elementus. Dabar jame yra tik keturi elementai ir visi yra lygūs 20.

Išplėskite vektorių naudodami Emplace ()

Jau žinome, kad nauji elementai dinamiškai įterpiami bet kurioje vektoriaus vietoje. Tai įmanoma naudojant vektorių::emplace() funkciją. Greitai pažvelkime į sintaksę ir parametrus, kuriuos priima ši funkcija.

Sintaksė:

vektorius. vieta ( const_iterator padėtis, elementas )

Šiai funkcijai perduodami du privalomi parametrai.

Čia:

  1. Pirmasis parametras užima poziciją, kad galėtume įterpti elementą bet kurioje padėtyje. Padėtį galime gauti naudodami start() arba end() iteratoriaus funkciją.
  2. Antrasis parametras yra elementas, kurį reikia įterpti į vektorių.

Apsvarstykite „cheminių medžiagų“ vektorių su dviem elementais.

  1. Pirmoje vietoje įrašykite „Manganas“ – pradžia (chemikalai)
  2. Paskutinėje vietoje įterpti „Varis“ – galas (chemikalai)
  3. Trečioje vietoje įrašykite „Siera“ – pradžia(chemikalai)+2
#include

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – cheminės medžiagos

vektorius < styga > chemikalai = { 'Deguonis' , 'CO' } ;

cout << „Tikrosios cheminės medžiagos:“ << endl ;

dėl ( tarpt i = 0 ; i < chemikalai. dydis ( ) ; i ++ )

cout << chemikalai [ i ] << endl ;



// Įterpti elementą pirmoje vietoje

chemikalai. vieta ( pradėti ( chemikalai ) , 'Manganas' ) ;



// Įterpti elementą paskutinėje vietoje

chemikalai. vieta ( galas ( chemikalai ) , 'Varis' ) ;



// Įterpti elementą trečioje vietoje

chemikalai. vieta ( pradėti ( chemikalai ) + 2 , 'Siera' ) ;



cout << \n Galutinės cheminės medžiagos: << endl ;

dėl ( tarpt i = 0 ; i < chemikalai. dydis ( ) ; i ++ )

cout << chemikalai [ i ] << endl ;

}

Išvestis:

Dabar galutiniame vektoriuje yra penki elementai (pateikta tolesnėje ekrano kopijoje).

Išplėskite vektorių naudodami Emplace_Back()

Elementą galima pridėti (pridedant vektoriaus pabaigoje), kurį galima padaryti naudojant vektorius::emplace_back() funkcija.

Sintaksė:

vektorius. emplace_back ( elementas )

Privaloma perduoti elementą, kurį reikia pridėti prie vektoriaus kaip parametrą.

Pridėkime du elementus vieną po kito naudodami funkciją emplace_back().

#include

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – cheminės medžiagos

vektorius < styga > chemikalai = { 'Deguonis' , 'CO' } ;

cout << „Tikrosios cheminės medžiagos:“ << endl ;

dėl ( tarpt i = 0 ; i < chemikalai. dydis ( ) ; i ++ )

cout << chemikalai [ i ] << endl ;



// Įterpti manganą vektoriaus gale

chemikalai. emplace_back ( 'Manganas' ) ;



// Įterpti manganą vektoriaus gale

chemikalai. emplace_back ( 'Varis' ) ;





cout << \n Galutinės cheminės medžiagos: << endl ;

dėl ( tarpt i = 0 ; i < chemikalai. dydis ( ) ; i ++ )

cout << chemikalai [ i ] << endl ;

}

Išvestis:

Dabar galutinis vektorius turi keturis elementus, pridėjus „manganą“ ir „varią“.

Maksimalus vektoriaus elementas

  1. Sukurkite vektorių su kai kuriais elementais.
  2. Norėdami rasti maksimalų elementą, esantį vektoriuje, naudokite funkciją *max_element(), kuri priima du iteratorius kaip argumentus. Šie du parametrai veikia kaip diapazonas, o didžiausias elementas grąžinamas pateiktame diapazone. Pradinė padėtis yra pradžia (), o paskutinė - pabaiga ().
* max_element ( pirmasis_indeksas, paskutinis_indeksas )

Panagrinėkime vektorių pavadinimu „item_costs“, kuris turi penkias sveikųjų skaičių tipo reikšmes ir grąžina maksimalų elementą.

#include

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – prekių_kainai

vektorius < tarpt > prekės_kainai = { 8900 , 5677 , 200 , 1000 , 2300 } ;



cout << „Prekių kaina: \n ;

dėl ( tarpt i = 0 ; i < prekės_kainai. dydis ( ) ; i ++ )

cout << prekės_kainai [ i ] << endl ;



// Grąžina maksimalų elementą iš aukščiau pateikto vektoriaus - item_costs

cout << \n Maksimali kaina: ' << * max_element ( pradėti ( prekės_kainai ) ,galas ( prekės_kainai ) ) ;

}

Išvestis:

Čia 8900 yra didžiausias elementas tarp visų elementų, esančių vektoriuje „item_costs“.

Minimalus vektoriaus elementas

  1. Sukurkite vektorių su kai kuriais elementais.
  2. Norėdami rasti mažiausią elementą, esantį vektoriuje, naudokite funkciją *min_element(), kuri priima du iteratorius kaip argumentus. Šie du parametrai veikia kaip diapazonas, o minimalus elementas (mažiau nei visi kiti elementai) grąžinamas pateiktame diapazone. Pradinė padėtis yra pradžia (), o paskutinė - pabaiga ().
* min_element ( pirmasis_indeksas, paskutinis_indeksas )

Naudokite tą patį vektorių, kuris sukurtas, kad surastumėte maksimalų elementą ir raskite mažiausią elementą naudodami funkciją *min_element().

#include

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – prekių_kainai

vektorius < tarpt > prekės_kainai = { 8900 , 5677 , 200 , 1000 , 2300 } ;



cout << „Prekių kaina: \n ;

dėl ( tarpt i = 0 ; i < prekės_kainai. dydis ( ) ; i ++ )

cout << prekės_kainai [ i ] << endl ;



// Grąžina minimalų elementą iš aukščiau pateikto vektoriaus - item_costs

cout << \n Minimali kaina: ' << * min_element ( pradėti ( prekės_kainai ) ,galas ( prekės_kainai ) ) ;

}

Išvestis:

Čia 200 yra mažiausias elementas tarp visų elementų, esančių vektoriuje „item_costs“.

Elementų suma vektoriuje

Norėdami grąžinti visų elementų, esančių vektoriuje, sumą, kaupti() C++ STL naudojama funkcija. Jis priima tris parametrus. Pirmasis parametras paima pirmąjį indeksą, kuris žymi pradinį elementą diapazone (nurodykite start() iteratorių), o antrasis parametras – paskutinį indeksą, kuris reiškia pabaigos elementą diapazone (nurodykite end() iteratorių). Galiausiai turime perduoti pradinę sumos reikšmę (mūsų atveju ji yra 0).

kaupti ( pirmasis_indeksas, paskutinis_indeksas, pradinis_valis ) ;

Sukurkite vektorių pavadinimu „item_costs“ su penkiais sveikųjų skaičių tipo elementais ir apskaičiuokite sumą.

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti vektorių – prekių_kainai

vektorius < tarpt > prekės_kainai = { 8900 , 5677 , 200 , 1000 , 2300 } ;



cout << „Prekių kaina: \n ;

dėl ( tarpt i = 0 ; i < prekės_kainai. dydis ( ) ; i ++ )

cout << prekės_kainai [ i ] << endl ;



// Grąžina visų aukščiau pateikto vektoriaus elementų sumą - item_costs

cout << \n Iš viso išlaidų: ' << kaupti ( pradėti ( prekės_kainai ) ,galas ( prekės_kainai ) , 0 ) ;

}

Išvestis:

8900, 5677, 200, 1000, 2300 suma yra 18077.

Dviejų vektorių daugyba pagal elementus

  1. Sukurkite du vektorius su skaitiniu tipu ir du vektoriai turi būti vienodo dydžio (bendras elementų skaičius pirmame vektoriuje = bendras elementų, esančių antrajame vektoriuje, skaičius).
  2. Paskelbkite naują vektorių ir naudokite už kilpą , atlikite dviejų elementų daugybos operaciją kiekvienoje iteracijoje ir išsaugokite vertę sukurtame vektoriuje naudodami funkciją push_back().
  3. dėl ( tarpt itr = 0 ; i < pirmasis_vec. dydis ( ) ; itr ++ )

    {

    rezultatas_vektorius. pastumti atgal ( pirmasis_vec [ itr ] * sek_daiktas [ itr ] ) ;

    }
  4. Parodykite elementus, esančius gautame vektoriuje, jį kartodami.

Sukurkite vektorių pavadinimu „item_costs“ su penkiais sveikųjų skaičių tipo elementais ir apskaičiuokite sumą.

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurkite du vektorius - produktai1 ir produktai2 su 5 elementais

vektorius < tarpt > produktai 1 = { 10 , dvidešimt , 30 , 40 , penkiasdešimt } ;

vektorius < tarpt > produktai 2 = { penkiasdešimt , 40 , 30 , 70 , 60 } ;



vektorius < tarpt > rezultatas_produktai ;



// Atlikti elementinį daugybą

dėl ( tarpt i = 0 ; i < produktai 1. dydis ( ) ; i ++ ) {

rezultatas_produktai. pastumti atgal ( produktai 1 [ i ] * produktai 2 [ i ] ) ;

}



// Rodyti gautą vektorių

cout << 'Vektoriaus daugyba: \n ;

dėl ( tarpt res : rezultatas_produktai )

cout << res << endl ;

}

Išvestis:

Iteracija - 1 : 10 * penkiasdešimt => 500

Iteracija - 2 : dvidešimt * 40 => 800

Iteracija - 3 : 30 * 30 => 900

Iteracija - 4 : 40 * 70 => 2800

Iteracija - 5 : penkiasdešimt * 60 => 3000

Dviejų vektorių taškinė sandauga

C++ vektorių atveju taškinė sandauga apibrėžiama kaip „dviejų vektorių sekų atitinkamų įrašų sandaugų suma“.

Sintaksė:

vidinis_produktas ( Vector1 pirmas, Vector1 paskutinis, Vector2 pirmas, Pradinis_Val )

Naudokite funkciją inner_product(), kad grąžintumėte taškinį produktą. Šiai funkcijai reikalingi keturi būtini parametrai.

Čia:

  1. Pirmasis parametras nurodo iteratorių, kuris nurodo pirmojo vektoriaus pradžią (nurodykite naudodami start() funkciją).
  2. Antrasis parametras nurodo iteratorių, kuris nurodo pirmojo vektoriaus pabaigą (nurodyti naudojant end() funkciją).
  3. Trečiasis parametras nurodo iteratorių, kuris nurodo antrojo vektoriaus pradžią (nurodykite naudodami start() funkciją).
  4. Pradinė vertė turi būti perduodama kaip paskutinis parametras, kuris yra sveikasis skaičius taško sandaugai kaupti.

Naudokite tą pačią programą, kuri sukurta dviejų vektorių dauginimui, ir naudokite funkciją innsr_product(), kad surastumėte dviejų vektorių taškinę sandaugą.

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurkite du vektorius - produktai1 ir produktai2 su 5 elementais

vektorius < tarpt > produktai 1 = { 10 , dvidešimt , 30 , 40 , penkiasdešimt } ;

vektorius < tarpt > produktai 2 = { penkiasdešimt , 40 , 30 , 70 , 60 } ;



// Rodyti gautą vektorių

cout << 'Produktų 1 ir produktų taškinis produktas: ' ;

cout << vidinis_produktas ( pradėti ( produktai 1 ) ,galas ( produktai 1 ) ,pradėkite ( produktai 2 ) , 0 ) ;

}

Išvestis:

( 10 * penkiasdešimt ) + ( dvidešimt * 40 ) + ( 30 * 30 ) + ( 40 * 70 ) + ( penkiasdešimt * 60 )

=> 500 + 800 + 900 + 2800 + 3000

=> 8000

Konvertuokite rinkinį į vektorių

Yra daug būdų, kaip aibę paversti vektoriumi, perduodant visus aibėje iškeltus elementus į vektorių. Geriausias ir paprasčiausias būdas yra naudoti funkciją std::copy().

Sintaksė

std :: kopija ( „sourceIterator“ pirmiausia, „sourceIterator“ paskutinis, pirmiausia „designIterator“. )

Naudoti std::copy() funkcija, kuri įterpia elementus iš aibės į vektorių. Tam reikia trijų parametrų.

Čia:

  1. Pirmasis parametras nurodo šaltinio iteratorių, kuris nurodo pirmąjį iteratoriaus elementą. Čia set yra šaltinio iteratorius, nurodytas naudojant start() funkciją.
  2. Panašiai antrasis parametras nurodo paskutinį elementą (funkcija end()).
  3. Trečiasis parametras nurodo paskirties iteratorių, kuris nurodo pirmąjį iteratoriaus elementą (nurodytą naudojant start() funkciją).

Sukurkime rinkinį su penkiais mokiniais ir naudodami ankstesnę funkciją nukopijuokime visus elementus į vektorių.

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurkite rinkinį – mokiniai su 5 elementais

rinkinys < styga > studentai = { 'Sravan' , 'Bobby' , 'Madhu' , 'Meghana' , 'Lavanija' } ;

cout << 'Nustatyti: \n ;

dėl ( styga i : studentai )

cout << i << endl ;



// Sukurti vektorių – student_vcof dydis lygus rinkinio dydžiui

vektorius < styga > studentas_vc ( studentai. dydis ( ) ) ;



// Įterpti elementus iš rinkinio – studentai į vektorių – student_vc.

kopija ( studentai. pradėti ( ) , studentai. galas ( ) , student_vc. pradėti ( ) ) ;



cout << \n Vektorius: \n ;

dėl ( styga i : studentas_vc )

cout << i << endl ;

}

Išvestis:

Dabar visi elementai, esantys rinkinyje „Students“, nukopijuojami į vektorių „studentai_vc“.

Pašalinkite pasikartojančius elementus

  1. Pirmiausia turime surūšiuoti vektoriaus elementus taip, kad visi pasikartojantys elementai būtų greta vienas kito naudojant std::rūšiuoti() funkcija.
  2. std :: rūšiuoti ( Pirmas vektorius, paskutinis vektorius ) ;
  3. Naudokite funkciją std::unique(), kad būtų pasirinkti pasikartojantys elementai. Tuo pačiu metu naudokite funkciją erase(), kad pašalintumėte dublikatus, kuriuos grąžina funkcija std::unique(). Galutiniame vektoriuje elementų tvarka gali keistis.
  4. vektorius. ištrinti ( std :: Unikalus ( Pirmas vektorius, paskutinis vektorius ) , Vektorius paskutinis ) )

Sukurkite „studentų“ vektorių su 10 elementų ir grąžinkite vektorių pašalindami dublikatus.

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurkite vektorių – mokiniai su 10 elementų

vektorius < styga > studentai = { 'Sravan' , 'Bobby' , 'Madhu' , 'Meghana' , 'Lavanija' ,

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

cout << 'Mokiniai: \n ;

dėl ( styga i : studentai )

cout << i << ' ' ;



// Rūšiuoti visus elementus studentų vektoriuje.

rūšiuoti ( pradėti ( studentai ) , galas ( studentai ) ) ;



// Naudokite unikalią () funkciją, kad pašalintumėte dublikatus naudodami funkciją erase ().

studentai. ištrinti ( Unikalus ( pradėti ( studentai ) , galas ( studentai ) ) , galas ( studentai ) ) ;



cout << \n \n Unikalūs studentai: \n ;

dėl ( automatinis itr = cbegin ( studentai ) ; itr ! = keletas ( studentai ) ; ++ itr ) {

cout << * itr << ' ' ;

}

}

Išvestis:

Dabar visi vektoriaus elementai yra unikalūs.

Paverskite vektorių į rinkinį

Nustatyti neleidžia pasikartojančių elementų. Jei rašote norėdami įterpti vektorių į rinkinį su dublikatais, jie bus ignoruojami. Naudojame tą pačią std::copy() funkciją, kuri buvo naudojama ankstesniame scenarijuje, kuris pavertė rinkinį į vektorių.

Pagal šį scenarijų:

  1. Pirmasis parametras naudoja vektorių kaip šaltinio iteratorių, kuris nurodomas naudojant start() funkciją.
  2. Antrasis parametras naudoja vektorių kaip šaltinio iteratorių, kuris nurodomas naudojant end() funkciją.
  3. Perduokite funkciją std::inserter(), kuri naudojama automatiškai perrašyti / nukopijuoti elementus tam tikroje rinkinio vietoje, kaip parametrus pateikiant rinkinį ir iteratorių, kurie nurodo rinkinio pabaigą.

Sukurkime vektorių su 10 sveikųjų skaičių ir nukopijuokime elementus į rinkinį.

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurti aibę – žymės su 10 reikšmių

vektorius < tarpt > ženklų = { 12 , 3. 4 , 56 , 78 , 65 , 78 , 90 , 90 , 78 , 3. 4 } ;

cout << 'Vektorius: \n ;

dėl ( tarpt i : ženklų )

cout << i << ' ' ;



// Sukurti rinkinį – žymų_rinkinys, kurio dydis lygus vektoriaus dydžiui

rinkinys < tarpt > marks_set ;



// Įterpti elementus iš rinkinio – studentai į vektorių – student_vc.

kopija ( pradėti ( ženklų ) ,galas ( ženklų ) , įterpiklis ( marks_set,end ( marks_set ) ) ) ;



cout << \n \n Nustatyti: \n ;

dėl ( tarpt i : marks_set )

cout << i << ' ' ;

}

Išvestis:

Esamas vektorius, pavadintas „ženklais“, turi 10 reikšmių. Nukopijavus jį į rinkinį „marks_set“, jame yra tik šeši elementai, nes kiti keturi elementai yra dubliuojami.

Pašalinkite tuščias eilutes

Nenaudojamos tuščios eilutės, esančios vektoriuje. Tai yra gera praktika pašalinti tuščias eilutes, kurios yra vektoriuje. Pažiūrėkime, kaip pašalinti tuščias eilutes iš C++ vektoriaus:

  1. Pakartokite vektorių naudodami „for“ kilpą.
  2. Kiekvienoje iteracijoje patikrinkite, ar elementas tuščias („““), ar nenaudojamas „==“ operatorius su at() nario funkcija.
  3. Naudodami funkciją std::erase() pašalinkite tuščias eilutes, patikrinę ankstesnę sąlygą.
  4. Kartokite 2 ir 3 veiksmus iki vektoriaus pabaigos.

Sukurkime „įmonių“ vektorių su 10 eilučių. Tarp jų penki yra tušti ir mes juos pašaliname taikydami ankstesnį metodą.

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( ) {



vektorius < styga > įmonių { 'Įmonė-A' , '' , „B įmonė“ ,

'' , „Company-C“ , '' , „D kompanija“ , '' , '' , '' } ;



// Pakartokite įmones

// ir pašalinkite tuščius elementus naudodami erase ()

dėl ( tarpt itr = 1 ; itr < įmonių. dydis ( ) ; ++ itr ) {

jeigu ( įmonių. adresu ( itr ) == '' ) {

įmonių. ištrinti ( įmonių. pradėti ( ) + itr ) ;

-- itr ;

}
}

// Rodyti vektorių


dėl ( automatinis & i : įmonių ) {

cout << i << endl ;

}

}

Išvestis:

Dabar „įmonių“ vektorius turi netuščias eilutes.

Į tekstinį failą įrašykite vektorių

Aptarkime, kaip įrašyti visus vektoryje esančius elementus į failą naudojant vektorinius indeksus naudojant fstream .

  1. Įstumkite kai kuriuos elementus į jį naudodami funkciją push_back po vektoriaus inicijavimo.
  2. Naudokite funkciją open() iš „fstream“ bibliotekos, kai režimas yra išjungtas.
  3. Pereikite kiekvieną elementą, esantį vektoriuje, naudodami indeksus „for“ kilpoje ir įrašykite kiekvieną elementą į pateiktą failą.
  4. Galiausiai uždarykite failą.

Įgyvendinkime ankstesnį metodą paleisdami C++ kodą.

#įtraukti

#include

#include

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Sukurkite vektorių - v_data

// ir įstumkite į jį du elementus.

vektorius < styga > v_duomenys ;

v_duomenys. pastumti atgal ( 'Sveiki' ) ;

v_duomenys. pastumti atgal ( 'į LinuxHint' ) ;

upelis f ;



// Atidarykite failą

f. atviras ( 'written_file.txt' ,ios_base :: išeiti ) ;

// Pakartokite kiekvieną vektoriaus elementą ir po vieną įrašykite į failą.

dėl ( tarpt i = 0 ; i < v_duomenys. dydis ( ) ; i ++ )

{

f << v_duomenys [ i ] << endl ;

}

// Uždarykite failą

f. Uždaryti ( ) ;

}

Išvestis:

„v_data“ vektorius turi du elementus ir failas sukuriamas kelyje, kuriame vykdoma programa su elementais, esančiais vektoriuje.

Sukurkite vektorių iš tekstinio failo

Išmokome į tekstinį failą įrašyti elementus, esančius vektoriuje. Čia sukurkime vektorių iš turinio, esančio tekstiniame faile.

  1. Sukurti „ ifstream“ kintamasis, kuris naudojamas informacijai nuskaityti iš tekstinio failo, kuriame sukuriame vektorių iš failo.
  2. Sukurkite tuščią vektorių, kad išsaugotumėte failo turinį, ir naudokite tuščią eilutės kintamąjį kaip vėliavėlę, kad patikrintumėte failo pabaigą.
  3. Skaitykite kitą failo eilutę, kol ji pasieks pabaigą (iš esmės naudojant „while“ kilpą). Naudokite funkciją push_back(), kad perskaitytumėte kitą eilutę ir įstumtumėte ją į vektorių.
  4. Atskirai parodykite eilutėje esančią eilutę, kad pamatytumėte elementus, esančius vektoriuje konsolėje.

Įgyvendinkime ankstesnį metodą paleisdami C++ kodą. Panagrinėkime failą „data.txt“, kurio turinys yra toks. Čia vektoriaus pavadinimas yra „v_data“.

#include

naudojant vardų erdvė std ;

pagrindinis ( )

{

// Atidarykite tekstinį failą – duomenys
ifstream failą ( 'duomenys.txt' ) ;

// Sukurti vektorių - v_data tipo - eilutė


vektorius < styga > v_duomenys ;

stringai buvo ;

// Skaitykite kitą eilutę iš failo data.txt
// kol pasieks pabaigą.


kol ( failą >> buvo ) {

// Perskaitykite kitą eilutę ir įstumkite į v_data

v_duomenys. pastumti atgal ( buvo ) ;

}



// Rodyti eilutėje esančią eilutę atskirai.

kopija ( v_duomenys. pradėti ( ) , v_duomenys. galas ( ) , ostream_iterator < styga > ( cout , \n ) ) ;

}

Išvestis:

Matome, kad „v_data“ turi penkis elementus, gautus iš failo.

Išvada

Šiame ilgame straipsnyje mes ištyrėme visus galimus pavyzdžius, kurie naudojami realiojo laiko programose, susijusiose su vektoriais C++ programavimo kalba. Kiekvienas pavyzdys paaiškinamas su sintaksė, parametrais ir pavyzdys su išvestimi. Komentarai pridedami prie kiekvieno kodo, kad būtų galima aiškiai suprasti kodą.