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:
- Matematinių vektorių vaizdavimas mokslinėse ir inžinerinėse programose
- 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:
- Įterpti elementą į vektorių
- Įterpti kelis elementus į vektorių
- Pasiekite elementus iš vektoriaus
- Atnaujinkite elementą vektoriuje
- Pašalinkite konkretų elementą iš vektoriaus
- Pašalinkite visus elementus iš vektoriaus
- Vektorių sąjunga
- Vektorių sankirta
- Patikrinkite, ar vektorius tuščias, ar ne
- Pereikite vektorių naudodami Const_Iterator
- Pereikite vektorių naudodami Reverse_Iterator
- Įstumkite elementus į vektorių
- Išskleiskite elementus iš vektoriaus
- Sukeiskite vektorius
- Paimkite pirmąjį elementą iš vektoriaus
- Paimkite paskutinį elementą iš vektoriaus
- Priskirkite vektoriui naujų reikšmių
- Išplėskite vektorių naudodami Emplace ()
- Išplėskite vektorių naudodami Emplace_Back()
- Maksimalus vektoriaus elementas
- Minimalus vektoriaus elementas
- Elementų suma vektoriuje
- Dviejų vektorių daugyba pagal elementus
- Dviejų vektorių taškinė sandauga
- Konvertuokite rinkinį į vektorių
- Pašalinkite pasikartojančius elementus
- Paverskite vektorių į rinkinį
- Pašalinkite tuščias eilutes
- Į tekstinį failą įrašykite vektorių
- 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().
#includenaudojant 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:
- Padėties parametras nurodo elemento padėtį, kurią reikia įterpti. Jei dydis yra didesnis nei 1, pradinės padėties indeksas bus pozicija.
- Dydžio parametras nurodo, kiek kartų elementas turi būti įterptas.
- 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.
#includenaudojant 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:
- Padėties parametras nurodo elemento padėtį, kurią reikia įterpti.
- „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ą).
- „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į.
#includenaudojant 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į.
#includenaudojant 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.
#includenaudojant 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'ką ( ) : 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 ] = ElementasApsvarstykite 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 ) = ElementasApsvarstykite „produktų“ vektorių su penkiais elementais. Atnaujinkite visus vektoriaus elementus su kitais elementais.
#includenaudojant 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.
- 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ą.
- Pašalinkite paskutinį elementą nurodydami end() iteratorių. End() nurodo paskutinį vektoriaus elementą.
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).
#includenaudojant 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().
#includenaudojant 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:
- „First1“ nurodo pirmąjį pirmojo iteratoriaus elementą (vektorių).
- „Last1“ nurodo paskutinį pirmojo iteratoriaus elementą (vektorių).
- „First2“ nurodo pirmąjį antrojo iteratoriaus elementą (vektorių).
- „Paskutinis2“ nurodo paskutinį antrojo iteratoriaus elementą (vektorių).
Sukurkite du vektorius – „subjects1“ ir „subjects2“ – sveikojo skaičiaus tipo.
- Surūšiuokite du vektorius naudodami funkciją sort () perduodant iteratorius.
- Sukurkite išvesties vektorių (iteratorių).
- Raskite šių dviejų vektorių sąjungą naudodami funkciją std::set_union(). Naudokite begin() kaip pirmąjį iteratorių ir end() kaip paskutinį iteratorių.
- Pakartokite išvesties vektorių, kad būtų rodomi elementai, kuriuos grąžina funkcija.
#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.
- Surūšiuokite du vektorius naudodami funkciją sort () perduodant iteratorius.
- Sukurkite išvesties vektorių (iteratorių).
- Raskite šių dviejų vektorių sankirtą naudodami funkciją std::set_intersection(). Naudokite begin() kaip pirmąjį iteratorių ir end() kaip paskutinį iteratorių.
- Pakartokite išvesties vektorių, kad būtų rodomi elementai, kuriuos grąžina funkcija.
#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.
- Sukurkime vektorių pavadinimu „departamentai“ su penkiomis eilutėmis.
- Paskelbkite const_iterator – ctr tipo
. - Pakartokite skyrius naudodami ankstesnį iteratorių naudodami kilpą „for“ ir parodykite jį.
#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.
- Sukurkime vektorių pavadinimu „departamentai“ su penkiomis eilutėmis.
- Paskelbkite reverse_iterator – rtr tipo
. - Pakartokite skyrius naudodami ankstesnį iteratorių naudodami kilpą „for“ ir parodykite jį.
#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:
- Sukurkite vektorių su visais panašiais elementais
- Pakeiskite esamą vektorių tuo pačiu elementu
Sintaksė:
vektorius. priskirti ( dydis, vertė )Šiai funkcijai reikalingi du parametrai.
Čia:
- Dydis nurodo elementų, kuriuos reikia priskirti, skaičių.
- 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:
- Pirmasis parametras užima poziciją, kad galėtume įterpti elementą bet kurioje padėtyje. Padėtį galime gauti naudodami start() arba end() iteratoriaus funkciją.
- Antrasis parametras yra elementas, kurį reikia įterpti į vektorių.
Apsvarstykite „cheminių medžiagų“ vektorių su dviem elementais.
- Pirmoje vietoje įrašykite „Manganas“ – pradžia (chemikalai)
- Paskutinėje vietoje įterpti „Varis“ – galas (chemikalai)
- Trečioje vietoje įrašykite „Siera“ – pradžia(chemikalai)+2
#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
- Sukurkite vektorių su kai kuriais elementais.
- 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 ().
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
- Sukurkite vektorių su kai kuriais elementais.
- 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 ().
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ą.
#includenaudojant 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
- 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).
- Paskelbkite naują vektorių ir naudokite už kilpą , atlikite dviejų elementų daugybos operaciją kiekvienoje iteracijoje ir išsaugokite vertę sukurtame vektoriuje naudodami funkciją push_back(). dėl ( tarpt itr = 0 ; i < pirmasis_vec. dydis ( ) ; itr ++ )
- Parodykite elementus, esančius gautame vektoriuje, jį kartodami.
{
rezultatas_vektorius. pastumti atgal ( pirmasis_vec [ itr ] * sek_daiktas [ itr ] ) ;
}
Sukurkite vektorių pavadinimu „item_costs“ su penkiais sveikųjų skaičių tipo elementais ir apskaičiuokite sumą.
#includenaudojant 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 => 500Iteracija - 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:
- Pirmasis parametras nurodo iteratorių, kuris nurodo pirmojo vektoriaus pradžią (nurodykite naudodami start() funkciją).
- Antrasis parametras nurodo iteratorių, kuris nurodo pirmojo vektoriaus pabaigą (nurodyti naudojant end() funkciją).
- Trečiasis parametras nurodo iteratorių, kuris nurodo antrojo vektoriaus pradžią (nurodykite naudodami start() funkciją).
- 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ą.
#includenaudojant 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:
- Pirmasis parametras nurodo šaltinio iteratorių, kuris nurodo pirmąjį iteratoriaus elementą. Čia set yra šaltinio iteratorius, nurodytas naudojant start() funkciją.
- Panašiai antrasis parametras nurodo paskutinį elementą (funkcija end()).
- 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ų.
#includenaudojant 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
- Pirmiausia turime surūšiuoti vektoriaus elementus taip, kad visi pasikartojantys elementai būtų greta vienas kito naudojant std::rūšiuoti() funkcija. std :: rūšiuoti ( Pirmas vektorius, paskutinis vektorius ) ;
- 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. vektorius. ištrinti ( std :: Unikalus ( Pirmas vektorius, paskutinis vektorius ) , Vektorius paskutinis ) )
Sukurkite „studentų“ vektorių su 10 elementų ir grąžinkite vektorių pašalindami dublikatus.
#includenaudojant 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ų:
- Pirmasis parametras naudoja vektorių kaip šaltinio iteratorių, kuris nurodomas naudojant start() funkciją.
- Antrasis parametras naudoja vektorių kaip šaltinio iteratorių, kuris nurodomas naudojant end() funkciją.
- 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į.
#includenaudojant 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:
- Pakartokite vektorių naudodami „for“ kilpą.
- Kiekvienoje iteracijoje patikrinkite, ar elementas tuščias („““), ar nenaudojamas „==“ operatorius su at() nario funkcija.
- Naudodami funkciją std::erase() pašalinkite tuščias eilutes, patikrinę ankstesnę sąlygą.
- 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 .
- Įstumkite kai kuriuos elementus į jį naudodami funkciją push_back po vektoriaus inicijavimo.
- Naudokite funkciją open() iš „fstream“ bibliotekos, kai režimas yra išjungtas.
- Pereikite kiekvieną elementą, esantį vektoriuje, naudodami indeksus „for“ kilpoje ir įrašykite kiekvieną elementą į pateiktą failą.
- 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.
- Sukurti „ ifstream“ kintamasis, kuris naudojamas informacijai nuskaityti iš tekstinio failo, kuriame sukuriame vektorių iš failo.
- 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ą.
- 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ų.
- 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ą.