30 Mga Halimbawa ng C++ Vectors

Sa C++, ang Vector ay isang isang dimensional na istraktura ng data na dynamic na pinapataas ang sarili nito batay sa kinakailangan. Ang organisasyon ng data (insertion/modification/delete) ay maaaring gawin nang mahusay sa istruktura ng data na ito. Kasama sa mga aplikasyon nito ang mga sumusunod:

1. Kinakatawan ang mga mathematical vectors sa mga aplikasyong pang-agham at engineering
2. Maaaring ipatupad ang mga pila, stack gamit ang istruktura ng data na ito, atbp.

Karamihan sa mga karaniwang pagpapatakbo at pag-andar ng CRUD na nauugnay sa istruktura ng data na ito ay tinatalakay nang detalyado sa senaryo na may syntax at mga snippet ng code.

Paksa ng Nilalaman:

1. Magpasok ng isang Elemento sa isang Vector
2. Magpasok ng Maramihang Elemento sa isang Vector
3. I-access ang Mga Elemento mula sa isang Vector
4. I-update ang Element sa isang Vector
5. Alisin ang isang Partikular na Elemento mula sa isang Vector
6. Alisin ang Lahat ng Elemento mula sa isang Vector
7. Unyon ng mga Vector
8. Intersection ng mga Vector
9. Suriin Kung Walang laman ang Vector o Hindi
10. Traverse a Vector Gamit ang Const_Iterator
11. Traverse a Vector Gamit ang Reverse_Iterator
12. Itulak ang Mga Elemento sa Vector
13. I-pop ang Mga Elemento mula sa Vector
14. Palitan ang mga Vector
15. Kunin ang Unang Elemento mula sa Vector
16. Kunin ang Huling Elemento mula sa Vector
17. Magtalaga ng mga Bagong Value sa isang Vector
18. Palawakin ang Vector Gamit ang Emplace()
19. Palawakin ang Vector Gamit ang Emplace_Back()
20. Pinakamataas na Elemento ng isang Vector
21. Pinakamababang Elemento ng isang Vector
22. Kabuuan ng mga Elemento sa isang Vector
23. Element-Wise Multiplication ng Dalawang Vector
24. Dot Product ng Dalawang Vector
25. I-convert ang isang Set sa isang Vector
26. Alisin ang Mga Duplicate na Elemento
27. I-convert ang isang Vector sa isang Set
28. Alisin ang Empty Strings
29. Sumulat ng Vector sa isang Text File
30. Gumawa ng Vector mula sa Text File

Magpasok ng isang Elemento sa isang Vector

Ang std::vector::insert() Ang function sa C++ STL ay ginagamit upang ipasok ang mga elemento sa tinukoy na posisyon.

Syntax:

Gamitin natin ang function na ito at ipasa ang unang posisyon bilang parameter na tumutukoy sa posisyon kung saan kailangang ipasok ang elemento at ibigay ang elemento bilang pangalawang parameter.

Ang begin() function ay maaaring gamitin dito upang ibalik ang isang iterator na tumuturo sa unang elemento ng input vector. Sa pamamagitan ng pagdaragdag ng posisyon sa function na ito, ipinapasok ang elemento sa posisyong iyon.

Gawin natin ang vector ng 'student_names' na may uri ng string at magpasok ng dalawang string sa una at pangalawang posisyon, isa-isa, gamit ang insert() function.

Output:

Dati, walang laman ang vector na 'estudyante_names'. Pagkatapos ng pagpasok, ang vector ay mayroong dalawang elemento.

Magpasok ng Maramihang Elemento sa isang Vector

Ginagamit namin ang parehong function na std::vector::insert() sa sitwasyong ito. Ngunit kailangan nating ipasa ang dagdag/iba't ibang mga parameter sa parehong function upang magpasok ng maraming elemento sa isang vector.

Sitwasyon 1: Pagpasok ng Isang Elemento nang Maraming Beses

Sa sitwasyong ito, idinaragdag namin ang parehong elemento nang maraming beses.

Syntax:

Upang gawin ito, kailangan nating ipasa ang laki bilang pangalawang parameter sa insert() function. Ang kabuuang mga parameter na ipinasa sa function na ito ay tatlo.

dito:

1. Tinutukoy ng parameter ng posisyon ang posisyon ng elemento na ilalagay. Kung mas malaki sa 1 ang laki, ang index ng panimulang posisyon ang magiging posisyon.
2. Tinutukoy ng parameter ng laki kung ilang beses ilalagay ang isang elemento.
3. Kinukuha ng parameter ng elemento ang elemento upang maipasok sa isang vector.

Isaalang-alang ang vector na 'student_names' na may dalawang string. Ipasok ang mga string ng 'Lavanya' ng limang beses sa pangalawang posisyon.

Output:

Sa umiiral na vector, ang 'Sravan Kumar' ay nasa unang posisyon at ang 'Lalitha' ay nasa pangalawang posisyon. Matapos ipasok ang 'Lavanya' ng limang beses (mula sa pangalawang posisyon hanggang sa ikaanim na posisyon), lumipat si 'Lalitha' sa ikapitong posisyon (huling).

Scenario 2: Paglalagay ng Maramihang Elemento

Sa sitwasyong ito, idinaragdag namin ang iba't ibang elemento sa isang pagkakataon mula sa isa pang vector. Ginagamit din namin ang parehong function dito ngunit magbabago ang syntax at mga parameter.

Syntax:

Upang gawin ito, kailangan nating ipasa ang laki bilang pangalawang parameter sa insert() function. Ang kabuuang mga parameter na ipinasa sa function na ito ay tatlo.

dito:

1. Tinutukoy ng parameter ng posisyon ang posisyon ng elemento na ilalagay.
2. Tinukoy ng “first_iterator” ang panimulang posisyon kung saan ilalagay ang mga elemento (sa pangkalahatan, gamit ang begin() function, ibabalik ang isang iterator na tumuturo sa unang elemento na nasa container).
3. Ang 'second_iterator' ay tumutukoy sa pagtatapos na posisyon hanggang sa kung saan ang mga elemento ay dapat ipasok (sa pangkalahatan, gamit ang end() function, isang iterator ay ibabalik na tumuturo sa tabi ng huling punto na naroroon sa lalagyan).

Lumikha ng dalawang vectors, 'marks1' at 'marks2', ng integer type. Ipasok ang lahat ng mga elemento na naroroon sa 'marks2' vector sa unang posisyon ng 'marks1' vector.

Output:

Ang unang vector (marks1) ay mayroong limang elemento at ang pangalawang vector (marks2) ay mayroong tatlong elemento. Ipinasa namin ang begin (marks1), begin(marks2), end(marks2) na mga parameter sa function na 'insert' upang ang lahat ng elemento na naroroon sa pangalawang vector ay inuulit at ipinasok sa unang vector sa simula. Kaya, ang unang vector ay mayroong walong elemento.

I-access ang Mga Elemento mula sa isang Vector

1. Gamit ang [] Operator

Sa ilang mga sitwasyon, maaaring kailanganin mong ibalik lamang ang mga partikular na elemento mula sa vector. Ang pagbabalik ng lahat ng mga elemento ay hindi kinakailangan. Kaya, upang ibalik lamang ang mga partikular na elemento batay sa index, ang index operator at at() function ay ginagamit.

Syntax:

Sa C++, ang pag-index ay nagsisimula sa 0 para sa anumang istraktura ng data. Kung wala ang elemento, babalik itong walang laman (Walang error o babala ang itinaas).

Isaalang-alang ang vector ng 'mga produkto' na may limang item. I-access ang lahat ng mga elemento nang paisa-isa gamit ang posisyon ng index.

Output:

Walang elementong naroroon sa index 8. Kaya, ibinalik ang walang laman.

2. Gamit ang At() Function

Ang At() ay isang function ng miyembro na katulad ng nakaraang use case ngunit ibinabalik nito ang 'std::out_of_range' exception kapag ang index na wala sa saklaw ay ibinigay dito.

Syntax:

Kailangan nating ipasa ang posisyon ng index sa function na ito.

Isaalang-alang ang vector ng 'mga produkto' na may limang item. I-access ang lahat ng mga elemento nang paisa-isa gamit ang posisyon ng index at subukang i-access ang elemento na naroroon sa ika-9 na posisyon.

Output:

Nagkaroon ng error para sa pag-access sa ika-9 na elemento:

I-update ang isang Elemento sa isang Vector

1. Gamit ang [] Operator

Gamit ang posisyon ng index, maaari naming i-update ang elemento sa vector. Kinukuha ng operator ng [] ang posisyon ng index ng elemento na kailangang i-update. Ang bagong elemento ay itatalaga sa operator na ito.

Syntax:

Isaalang-alang ang vector na 'student_marks' na may limang value. I-update ang mga elementong naroroon sa mga indeks 1 at 3.

Output:

Makikita natin na ang panghuling vector ang may hawak ng mga elemento ng pag-update sa mga indeks 1 at 3.

2. Gamit ang At() Function

Katulad ng index operator, at() ay karaniwang isang function ng miyembro na nag-a-update ng halaga batay sa index sa isang iterator. Kung ang index na tinukoy sa loob ng function na ito ay hindi umiiral, ang 'std::out_of_range' exception ay itatapon.

Isaalang-alang ang vector ng 'mga produkto' na may limang item. I-update ang lahat ng mga elemento na naroroon sa vector kasama ng iba pang mga elemento.

Output:

Alisin ang isang Partikular na Elemento mula sa isang Vector

Sa C++, ang std::vector::erase() Ang function ay ginagamit upang alisin ang isang partikular na elemento/saklaw ng mga elemento mula sa isang vector. Ang mga elemento ay tinanggal batay sa mga posisyon ng iterator.

Syntax:

Tingnan natin ang syntax para sa pag-alis ng partikular na elemento mula sa isang vector. Maaari naming gamitin ang begin() o end() function para makuha ang posisyon ng elementong naroroon sa vector na aalisin.

Isaalang-alang ang vector ng 'mga produkto' na may limang item.

1. Alisin ang ikatlong elemento sa pamamagitan ng pagtukoy sa begin() iterator. Ang Begin() ay tumuturo sa unang elemento sa vector. Kung magdadagdag tayo ng dalawa sa function na ito, itinuturo nito ang ikatlong elemento.
2. Alisin ang huling elemento sa pamamagitan ng pagtukoy sa end() iterator. End() ay tumuturo sa huling elemento sa vector.

Output:

Ngayon, mayroon lamang tatlong elemento ('soap', 'shampoo', 'prutas') na umiiral sa vector ng 'mga produkto'.

Alisin ang Lahat ng Elemento mula sa isang Vector

Sitwasyon 1: Mag-alis ng Saklaw ng mga Elemento mula sa isang Vector

Gamitin natin ang std::vector::erase() function para alisin ang maraming elemento sa isang range.

Syntax:

Ang dalawang iterator (begin() ay tumuturo sa unang elemento at end() na tumuturo sa mga huling function ng elemento) ay ginagamit upang tukuyin ang saklaw.

Isaalang-alang ang vector ng 'mga produkto' na may limang mga item at alisin ang lahat ng mga elemento mula sa pangalawang posisyon. Upang makamit ito, ang unang iterator ay magsisimula (mga produkto)+1 na tumuturo sa pangalawang elemento at ang pangalawang iterator ay wakas (mga produkto).

Output:

Ngayon, mayroon lamang isang elemento ('sabon') na nasa vector ng 'mga produkto'.

Scenario 2: Alisin ang Lahat ng Elemento mula sa Vector

Gamitin natin ang std::vector::clear() function na alisin ang lahat ng mga elemento mula sa vector.

Syntax:

Walang mga parameter na ipinapasa sa function na ito.

Isaalang-alang ang parehong vector na ginamit sa unang senaryo at alisin ang lahat ng mga elemento gamit ang clear() function.

Output:

Makikita natin na walang mga elemento sa vector ng 'mga produkto'.

Unyon ng mga Vector

Posibleng gawin ang operasyon ng UNION sa mga vector gamit ang std::set_union() function. Ibinabalik ng Union ang mga natatanging elemento mula sa mga vector sa pamamagitan ng hindi pagpansin sa mga dobleng elemento. Kailangan nating ipasa ang parehong mga iterator sa function na ito. Kasama nito, kailangang maipasa ang isang output iterator na nag-iimbak ng resulta na ibinalik ng parehong mga iterator.

Syntax:

dito:

1. Ang 'first1' ay tumuturo sa unang elemento ng unang iterator (vector).
2. Ang 'last1' ay tumuturo sa huling elemento ng unang iterator (vector).
3. Ang 'first2' ay tumuturo sa unang elemento ng pangalawang iterator (vector).
4. Ang 'last2' ay tumuturo sa huling elemento ng pangalawang iterator (vector).

Lumikha ng dalawang vectors - 'mga paksa1' at 'mga paksa2' - ng uri ng integer.

1. Pagbukud-bukurin ang dalawang vector gamit ang sort() function sa pamamagitan ng pagpasa sa mga iterator.
2. Lumikha ng isang output vector (iterator).
3. Hanapin ang unyon ng dalawang vector na ito gamit ang std::set_union() function. Gamitin ang begin() bilang unang iterator at end() bilang huling iterator.
4. Ulitin ang output vector upang ipakita ang mga elemento na ibinalik ng function.

Output:

Mayroon lamang limang natatanging elemento sa parehong mga vector (mga paksa1 at paksa2).

Intersection ng mga Vector

Ang paghahanap ng intersection ng dalawang vector ay maaaring maging posible gamit ang std::set_intersection() function. Ibinabalik ng intersection ang mga elemento na naroroon sa parehong mga vector.

Syntax:

Ang mga parameter na ipapasa sa set_union() function ay maaaring ipasa din sa set_intersection() function na ito.

Lumikha ng dalawang vectors - 'mga paksa1' at 'mga paksa2' - ng uri ng integer.

1. Pagbukud-bukurin ang dalawang vector gamit ang sort() function sa pamamagitan ng pagpasa sa mga iterator.
2. Lumikha ng isang output vector (iterator).
3. Hanapin ang intersection ng dalawang vector na ito gamit ang std::set_intersection() function. Gamitin ang begin() bilang unang iterator at end() bilang huling iterator.
4. Ulitin ang output vector upang ipakita ang mga elemento na ibinalik ng function.

Output:

Mayroon lamang tatlong elemento na naroroon sa parehong mga vector (mga paksa1 at paksa2).

Suriin Kung Walang laman ang Vector o Hindi

Bago magtrabaho sa mga vector, mahalagang suriin kung ang vector ay walang laman o hindi. Ito rin ay isang mahusay na kasanayan sa mga proyekto ng software upang suriin kung ang vector ay walang laman o wala bago gawin ang mga operasyon tulad ng mga operasyon ng CRUD, atbp.

1. Gamit ang Std::vector::empty()

Ang function na ito ay nagbabalik ng 1 kung ang vector ay walang laman (hindi naglalaman ng anumang elemento). Kung hindi, 0 ang ibinalik. Walang parameter na ipinapasa sa function na ito.

2. Gamit ang Std::vector::size()

Ang std::vector::size() function ay nagbabalik ng integer na kumakatawan sa kabuuang bilang ng mga elemento na nasa vector.

Lumikha ng dalawang vectors – “college1” at “college2”. Ang 'College1' ay mayroong limang elemento at ang 'college2' ay walang laman. Ilapat ang parehong mga function sa parehong mga vector at suriin ang output.

Output:

Ang empty() function ay nagbabalik ng 0 para sa “college1” at 1 para sa “college2”. Ang size() function ay nagbabalik ng lima para sa “college1” at 0 para sa “college2”.

Traverse a Vector Gamit ang Const_Iterator

Kapag nagtatrabaho ka sa mga C++ na lalagyan tulad ng mga set, vector, atbp., posibleng umulit sa lahat ng elementong nasa container nang hindi binabago ang mga ito. Ang const_iterator ay isa sa mga iterator na nakakamit ang sitwasyong ito. Ang cbegin() (tumuturo sa unang elemento sa vector) at cend() (tumuturo sa huling elemento sa vector) ay ang dalawang function na ibinibigay ng bawat lalagyan na ginagamit upang ibalik ang constant iterator sa simula at dulo ng ang lalagyan. Habang inuulit ang vector, magagamit natin ang dalawang function na ito.

1. Gumawa tayo ng vector na pinangalanang 'mga departamento' na may limang string.
2. Magdeklara ng const_iterator – ctr ng uri .
3. Ulitin ang mga departamento gamit ang nakaraang iterator gamit ang 'para sa' loop at ipakita ito.

Output:

Traverse a Vector Gamit ang Reverse_Iterator

Ang reverse_iterator ay isa ring iterator na katulad ng const_iterator ngunit ibinabalik nito ang mga elemento sa kabaligtaran. Ang rbegin() (tumuturo sa huling elemento sa vector) at rend() (tumuturo sa unang elemento sa vector) ay ang dalawang function na ibinibigay ng bawat lalagyan na ginagamit upang ibalik ang pare-parehong iterator sa pagtatapos at simula ng ang lalagyan.

1. Gumawa tayo ng vector na pinangalanang 'mga departamento' na may limang string.
2. Magdeklara ng reverse_iterator – rtr ng uri .
3. Ulitin ang mga departamento gamit ang nakaraang iterator gamit ang 'para sa' loop at ipakita ito.

Output:

Itulak ang Mga Elemento sa Vector

Ang pagtulak o pagdaragdag ng mga elemento sa isang vector ay isang one-way na pagpapasok na maaaring gawin gamit ang vector::push_back() function.

Syntax:

Kinakailangan ang isang elemento upang itulak sa vector bilang isang parameter.

Gumawa tayo ng isang walang laman na vector na pinangalanang 'mga departamento' na may limang mga string at itulak ang dalawang mga string nang sunud-sunod gamit ang push_back() function.

Output:

Una, itinutulak namin ang 'Sales'. Pagkatapos nito, ang 'IT' ay itinulak sa vector. Ngayon, ang vector ng 'mga departamento' ay mayroong dalawang elemento.

I-pop ang Mga Elemento mula sa Vector

Kung gusto mong tanggalin ang huling item na naroroon sa vector, gamit ang vector::pop_back() function ay ang pinakamahusay na diskarte. Tinatanggal nito ang huling elemento na naroroon sa vector.

Syntax:

Walang kinakailangang parameter para sa function na ito. Ipinapakita nito ang hindi natukoy na gawi kung susubukan naming tanggalin ang huling elemento mula sa isang walang laman na vector.

Gumawa tayo ng isang walang laman na vector na pinangalanang 'mga departamento' na may limang mga string at tanggalin ang huling elemento gamit ang nakaraang function. Ipakita ang vector sa parehong mga kaso.

Output:

Ang 'HR' ay ang huling elemento na nasa vector ng 'mga departamento.' Kaya, ito ay tinanggal mula sa vector at ang huling vector ay may hawak na 'Sales', 'IT', 'Serbisyo', at 'Marketing'.

Palitan ang mga Vector

Ang vector::swap() Ang function sa C++ STL ay ginagamit upang palitan ang lahat ng mga elemento na naroroon sa dalawang vectors.

Syntax:

Hindi nito isinasaalang-alang ang laki ng mga vector ngunit ang mga vector ay dapat na pareho ang uri (ang error ay itinapon kung ang mga uri ng vector ay iba).

Gumawa tayo ng dalawang vectors - 'prutas' at 'gulay' - ng uri ng string na may iba't ibang laki. Pagpalitin ang bawat isa sa kanila at ipakita ang mga vector sa parehong mga kaso.

Output:

Dati, ang vector ng 'prutas' ay mayroong dalawang elemento at ang 'gulay' na vector ay mayroong tatlong elemento. Pagkatapos magpalit, ang vector ng 'prutas' ay mayroong tatlong elemento at ang 'gulay' na vector ay mayroong dalawang elemento.

Kunin ang Unang Elemento mula sa Vector

Sa ilang mga kaso, ang kinakailangan ay ibalik lamang ang unang elemento mula sa vector. Kinukuha lang ng vector::front() function sa C++ STL ang unang elemento mula sa vector.

Syntax:

Ang function na ito ay hindi kukuha ng anumang parameter. Kung ang vector ay walang laman, ang isang error ay itinapon.

Gumawa tayo ng dalawang vectors - 'prutas' at 'gulay' - ng uri ng string at subukang kunin ang unang elemento nang hiwalay sa dalawang vector.

Output:

Ang 'Apple' ay ang unang elemento na naroroon sa vector ng 'prutas'. Kaya, ito ay ibinalik. Ngunit ang isang error ay itinapon kapag sinubukan naming kunin ang unang elemento mula sa vector na 'gulay' dahil ito ay walang laman.

Kunin ang Huling Elemento mula sa Vector

Ang vector::end() function sa C++ STL ay kumukuha lamang ng huling elemento mula sa vector.

Syntax:

Ang function na ito ay hindi kukuha ng anumang parameter. Kung ang vector ay walang laman, ang isang error ay itinapon.

Gumawa tayo ng dalawang vectors - 'prutas' at 'gulay' - ng uri ng string at subukang kunin ang huling elemento nang hiwalay sa dalawang vector.

Output:

Ang 'Mango' ay ang huling elemento na naroroon sa vector ng 'prutas'. Kaya, ito ay ibinalik. Ngunit ang isang error ay itinapon kapag sinubukan naming kunin ang huling elemento mula sa vector na 'gulay' dahil ito ay walang laman.

Magtalaga ng mga Bagong Value sa isang Vector

Sa ilang mga sitwasyon, kung gusto mong i-update ang lahat ng value gamit ang bagong value o lumikha ng vector na may parehong value, gamit ang vector::assign() function ay ang pinakamahusay na diskarte. Gamit ang function na ito, maaari nating:

1. Lumikha ng vector kasama ang lahat ng magkakatulad na elemento
2. Baguhin ang umiiral na vector na may parehong elemento

Syntax:

Dalawang parameter ang kinakailangan sa function na ito.

dito:

1. Tinutukoy ng laki ang bilang ng mga elementong itatalaga.
2. Tinutukoy ng value ang elementong itatalaga.

Gumawa tayo ng vector na pinangalanang 'marks1' na may limang value at i-update ang vector na ito na may apat na elemento upang ang lahat ng elemento sa na-update na vector ay katumbas ng 20.

Output:

Noong nakaraan, ang vector ay mayroong limang magkakaibang elemento. Ngayon, mayroon lamang itong apat na elemento at lahat ay katumbas ng 20.

Palawakin ang Vector Gamit ang Emplace()

Alam na natin na ang mga bagong elemento ay dynamic na ipinapasok sa anumang posisyon sa isang vector. Ito ay posible gamit ang vector::emplace() function. Mabilis nating tingnan ang syntax at mga parameter na tinatanggap ng function na ito.

Syntax:

Dalawang mandatoryong parameter ang ipinapasa sa function na ito.

dito:

1. Kinukuha ng unang parameter ang posisyon upang maipasok namin ang elemento sa anumang posisyon. Makukuha natin ang posisyon gamit ang begin() o end() iterator function.
2. Ang pangalawang parameter ay ang elementong ilalagay sa vector.

Isaalang-alang ang vector ng 'mga kemikal' na may dalawang elemento.

1. Ipasok ang 'Manganese' sa unang posisyon - magsimula (mga kemikal)
2. Ipasok ang 'Copper' sa huling posisyon - dulo (mga kemikal)
3. Ipasok ang 'Sulphur' sa ikatlong posisyon - magsimula(mga kemikal)+2

Output:

Ngayon, ang huling vector ay mayroong limang elemento (ibinigay sa sumusunod na screenshot).

Palawakin ang Vector Gamit ang Emplace_Back()

Maaaring idagdag ang isang elemento (pagdaragdag sa dulo ng vector) na maaaring gawin gamit ang vector::emplace_back() function.

Syntax:

Ito ay ipinag-uutos na ipasa ang elemento na idaragdag sa vector bilang isang parameter.

Magdagdag tayo ng dalawang elemento nang sunud-sunod gamit ang emplace_back() function.

Output:

Ngayon, ang huling vector ay mayroong apat na elemento pagkatapos idagdag ang 'Manganese' at 'Copper'.

Pinakamataas na Elemento ng isang Vector

1. Lumikha ng isang vector na may ilang mga elemento.
2. Upang mahanap ang maximum na elemento na nasa vector, gamitin ang *max_element() function na tumatanggap ng dalawang iterator bilang mga argumento. Ang dalawang parameter na ito ay nagsisilbing hanay at ang maximum na elemento ay ibinalik sa loob ng ibinigay na hanay. Ang panimulang posisyon ay begin() at ang huling posisyon ay end().

Isaalang-alang natin ang isang vector na pinangalanang 'item_costs' na nagtataglay ng limang halaga ng uri ng integer at ibabalik ang maximum na elemento.

Output:

Dito, ang 8900 ay ang pinakamataas na elemento sa lahat ng mga elemento na naroroon sa vector ng 'item_costs'.

Pinakamababang Elemento ng isang Vector

1. Lumikha ng isang vector na may ilang mga elemento.
2. Upang mahanap ang pinakamababang elemento na naroroon sa vector, gamitin ang *min_element() function na tumatanggap ng dalawang iterator bilang mga argumento. Ang dalawang parameter na ito ay nagsisilbing hanay at ang pinakamababang elemento (mas mababa sa lahat ng iba pang elemento) ay ibinalik sa loob ng ibinigay na hanay. Ang panimulang posisyon ay begin() at ang huling posisyon ay end().

Gamitin ang parehong vector na nilikha upang mahanap ang maximum na elemento at hanapin ang minimum na elemento gamit ang *min_element() function.

Output:

Dito, ang 200 ay ang pinakamababang elemento sa lahat ng mga elemento na naroroon sa vector ng 'item_costs'.

Kabuuan ng mga Elemento sa isang Vector

Upang ibalik ang kabuuan ng lahat ng mga elemento na naroroon sa vector, ang mag-ipon() Ang function sa C++ STL ay ginagamit. Tumatanggap ito ng tatlong mga parameter. Kinukuha ng unang parameter ang unang index na kumakatawan sa panimulang elemento sa hanay (tukuyin ang begin() iterator) at ang pangalawang parameter ay kumukuha ng huling index na kumakatawan sa panghuling elemento sa hanay (tukuyin ang end() iterator) . Panghuli, kailangan nating ipasa ang paunang halaga ng kabuuan (sa aming kaso, ito ay 0).

Gumawa ng vector na pinangalanang 'item_costs' na may limang elemento ng uri ng integer at kalkulahin ang kabuuan.

Output:

Ang kabuuan ng 8900, 5677, 200, 1000, 2300 ay 18077.

Element-Wise Multiplication ng Dalawang Vector

1. Gumawa ng dalawang vector na may uri ng numeric at dalawang vector ay dapat magkapareho ang laki (kabuuang bilang ng mga elementong nasa unang vector = kabuuang bilang ng mga elementong nasa pangalawang vector).
2. Magdeklara ng bagong vector at gamitin ang para sa loop , isagawa ang multiplication operation sa dalawang elemento sa bawat pag-ulit, at iimbak ang halaga sa nilikhang vector gamit ang push_back() function.
para sa ( int itr = 0 ; i < first_vec. laki ( ) ; itr ++ )

{

resulta_vector. push_back ( first_vec [ itr ] * sec_thing [ itr ] ) ;

}
3. Ipakita ang mga elemento na naroroon sa resultang vector sa pamamagitan ng pag-ulit nito.

Gumawa ng vector na pinangalanang 'item_costs' na may limang elemento ng uri ng integer at kalkulahin ang kabuuan.

Output:

Dot Product ng Dalawang Vector

Sa kaso ng mga C++ vectors, ang tuldok na produkto ay tinukoy bilang 'kabuuan ng mga produkto ng kaukulang mga entry ng dalawang sequence ng mga vectors'.

Syntax:

Gamitin ang inner_product() function para ibalik ang dot product. Ang function na ito ay tumatagal ng apat na kinakailangang parameter.

dito:

1. Ang unang parameter ay tumutukoy sa isang iterator na tumuturo sa simula ng unang vector (tukuyin gamit ang begin() function).
2. Ang pangalawang parameter ay tumutukoy sa isang iterator na tumuturo sa pagtatapos ng unang vector (tukuyin gamit ang end() function).
3. Ang ikatlong parameter ay tumutukoy sa isang iterator na tumuturo sa simula ng pangalawang vector (tukuyin gamit ang begin() function).
4. Ang paunang halaga ay kailangang maipasa bilang huling parameter na isang integer para sa akumulasyon ng produkto ng tuldok.

Gamitin ang parehong program na nilikha para sa pagpaparami ng dalawang vector at gamitin ang innsr_product() function upang mahanap ang tuldok na produkto ng dalawang vector.

Output:

I-convert ang isang Set sa isang Vector

Mayroong maraming mga paraan upang i-convert ang isang set sa isang vector sa pamamagitan ng pagpasa sa lahat ng mga elemento na nakataas sa isang set sa isang vector. Ang pinakamahusay at pinakasimpleng paraan ay ang paggamit ng std::copy() function.

Syntax

Gamitin ang std::copy() function na naglalagay ng mga elemento mula sa isang set papunta sa vector. Ito ay tumatagal ng tatlong mga parameter.

dito:

1. Ang unang parameter ay tumutukoy sa source iterator na tumuturo sa unang elemento sa iterator. Dito, ang set ay ang source iterator na tinukoy gamit ang begin() function.
2. Katulad nito, ang pangalawang parameter ay tumuturo sa huling elemento (end() function).
3. Ang ikatlong parameter ay tumutukoy sa patutunguhang iterator na tumuturo sa unang elemento (tinukoy gamit ang begin() function)  sa iterator.

Gumawa tayo ng set na may limang estudyante at kopyahin ang lahat ng elemento sa isang vector gamit ang nakaraang function.

Output:

Ngayon, ang lahat ng mga elemento na naroroon sa hanay ng 'Mga Mag-aaral' ay kinopya sa vector ng 'mga mag-aaral_vc'.

Alisin ang Mga Duplicate na Elemento

1. Una, kailangan nating pag-uri-uriin ang mga elemento sa vector upang ang lahat ng mga dobleng elemento ay magkatabi sa bawat isa gamit ang std::sort() function.
std :: uri ( Vector una, Vector huli ) ;
2. Gamitin ang std::unique() function para mapili ang mga duplicate na elemento. Kasabay nito, gamitin ang erase() function upang alisin ang mga duplicate na ibinalik ng std::unique() function. Ang pagkakasunud-sunod ng mga elemento ay maaaring magbago sa huling vector.
vector. burahin ( std :: kakaiba ( Vector una, Vector huli ) , Vector huling ) )

Gumawa ng vector na 'mga mag-aaral' na may 10 elemento at ibalik ang vector sa pamamagitan ng pag-alis ng mga duplicate.

Output:

Ngayon, ang lahat ng mga elemento ay natatangi sa vector.

I-convert ang isang Vector sa isang Set

Hindi pinapayagan ng set ang mga duplicate na elemento. Kung nagta-type ka upang magpasok ng vector sa isang set na may mga duplicate, hindi sila papansinin. Ginagamit namin ang parehong std::copy() function na ginamit sa nakaraang senaryo na nag-convert ng set sa isang vector.

Sa ganitong senaryo:

1. Kinukuha ng unang parameter ang vector bilang source iterator na tinukoy gamit ang begin() function.
2. Kinukuha ng pangalawang parameter ang vector bilang source iterator na tinukoy gamit ang end() function.
3. Ipasa ang std::inserter() function na ginagamit upang awtomatikong i-overwrite/kopyahin ang mga elemento sa isang partikular na posisyon sa set sa pamamagitan ng pagbibigay ng set at iterator na tumuturo sa dulo ng set bilang mga parameter.

Gumawa tayo ng vector na may 10 integer at kopyahin ang mga elemento sa isang set.

Output:

Ang umiiral na vector na pinangalanang 'marks' ay may 10 mga halaga. Pagkatapos kopyahin ito sa set na 'marks_set', mayroon lamang itong anim na elemento dahil ang iba pang apat na elemento ay nadoble.

Alisin ang Empty Strings

Walang paggamit ng mga walang laman na string na naroroon sa isang vector. Ito ay isang magandang kasanayan upang alisin ang mga walang laman na string na naroroon sa vector. Tingnan natin kung paano alisin ang mga walang laman na string mula sa C++ vector:

1. Ulitin ang vector gamit ang 'para' na loop.
2. Sa bawat pag-ulit, tingnan kung walang laman ang elemento (“”) o hindi gumagamit ng “==” operator na may at() member function.
3. Gamit ang std::erase() function, alisin ang mga walang laman na string pagkatapos suriin ang nakaraang kundisyon.
4. Ulitin ang step2 at step3 hanggang sa dulo ng vector.

Gawin natin ang vector ng 'mga kumpanya' na may 10 string. Kabilang sa mga ito, lima ang walang laman at inalis namin ang mga ito sa pamamagitan ng pagpapatupad ng nakaraang diskarte.

Output:

Ngayon, hawak ng vector ng 'mga kumpanya' ang mga hindi laman na string.

Sumulat ng Vector sa isang Text File

Talakayin natin kung paano isulat ang lahat ng mga elemento na naroroon sa isang vector sa isang file gamit ang mga indeks ng vector gamit ang fstream .

1. Itulak ang ilang elemento dito gamit ang push_back function pagkatapos masimulan ang vector.
2. Gamitin ang open() function mula sa 'fstream' na library na ang mode ay lumabas.
3. Traverse bawat elemento na naroroon sa vector gamit ang mga indeks sa isang 'para sa' loop at isulat ang bawat elemento sa ibinigay na file.
4. Panghuli, isara ang file.

Ipatupad natin ang nakaraang diskarte sa pamamagitan ng pagpapatakbo ng C++ code.

Output:

Ang 'v_data' vector ay may hawak na dalawang elemento at isang file ay nilikha sa landas kung saan ang programa ay pinaandar kasama ang mga elemento na naroroon sa vector.

Gumawa ng Vector mula sa Text File

Natutunan namin kung paano isulat ang mga elemento na naroroon sa vector sa isang text file. Dito, gumawa tayo ng vector mula sa content na nasa text file.

1. Lumikha ng ' ifstream” variable na ginagamit upang basahin ang impormasyon mula sa text file kung saan nilikha namin ang vector mula sa file.
2. Lumikha ng isang walang laman na vector upang mag-imbak ng nilalaman ng file at gumamit ng isang walang laman na string variable bilang isang bandila upang suriin ang dulo ng file.
3. Basahin ang susunod na linya mula sa file hanggang sa maabot nito ang dulo (karaniwang gamit ang 'habang' loop). Gamitin ang push_back() function para basahin ang susunod na linya at itulak ito sa vector.
4. Ipakita ang linya na naroroon sa linya nang hiwalay upang makita ang mga elemento na nasa vector sa console.

Ipatupad natin ang nakaraang diskarte sa pamamagitan ng pagpapatakbo ng C++ code. Isaalang-alang natin ang 'data.txt' file na may sumusunod na nilalaman. Dito, ang pangalan ng vector ay 'v_data'.

Output:

Makikita natin na ang 'v_data' ay mayroong limang elemento na nagmula sa file.

Konklusyon

Sa mahabang artikulong ito, ginalugad namin ang lahat ng posibleng halimbawa na ginagamit sa mga real-time na application na nauugnay sa mga vector sa C++ programming language. Ang bawat halimbawa ay ipinaliwanag sa syntax, mga parameter, at halimbawa na may output. Ang mga komento ay idinaragdag sa bawat code upang makakuha ng malinaw na pag-unawa sa code.