Paano Gumamit ng C ++ Vector

Panimula

Ang isang array ay isang serye ng parehong mga uri ng object sa magkakasunod na mga lokasyon ng memorya. Hindi maaaring dagdagan ng isang array ang pagbawas ng mineral sa haba. Ang isang vector ay tulad ng isang array, ngunit ang haba nito ay maaaring madagdagan o mabawasan. Ang isang vector, samakatuwid, ay may mas maraming mga operasyon kaysa sa isang array.

Ang C ++ ay may maraming mga aklatan, na pawang bumubuo sa C ++ Standard Library. Ang isa sa mga aklatan na ito ay ang lalagyan ng silid-aklatan. Ang isang lalagyan ay isang koleksyon ng mga bagay, at ang ilang mga pagpapatakbo ay maaaring isagawa sa koleksyon. Ang mga lalagyan ng C ++ ay maaaring mapangkat sa dalawang mga hanay: mga lalagyan ng pagkakasunud-sunod at mga nauugnay na lalagyan. Ang mga lalagyan ng pagkakasunud-sunod ay vector, array (hindi pareho ng tinalakay na array dati), deque, forward_list, at listahan. Ito ay magkakaibang mga koleksyon (tulad ng mga istruktura ng data na tulad ng array), at bawat isa ay nag-aalok ng magkakaibang mga trade-off.

Ang anumang programmer ay dapat malaman kung paano magpasya kung gagamit ng isang vector, isang array, isang deque, isang forward_list, o isang listahan. Kapag ang isang programmer ay nangangailangan ng isang istraktura na nangangailangan ng higit na mga operasyon kaysa sa mga nauugnay sa isang ordinaryong array, hindi dapat gamitin ang ordinaryong array.

Kung ang gawain ay nagsasangkot ng madalas na pagpasok at pagtanggal sa gitna ng pagkakasunud-sunod, pagkatapos ay dapat gamitin ang isang listahan o forward_list. Kung ang gawain ay nagsasangkot ng madalas na pagpasok at pagtanggal sa simula o pagtatapos ng isang pagkakasunud-sunod, dapat gamitin ang isang deque. Dapat gamitin ang isang vector kapag hindi kinakailangan ang mga ganitong uri ng pagpapatakbo.

Ipinapakita sa iyo ng artikulong ito kung paano gamitin ang C ++ vector. Kakailanganin mo ng kaunting kaalaman sa mga panuto ng C ++, sanggunian, at array upang maunawaan ang artikulong ito.

Klase at Mga Bagay

Ang isang klase ay isang hanay ng mga variable at pag-andar na nagtutulungan, kung saan ang mga variable ay walang mga itinalagang halaga. Kapag ang mga halaga ay itinalaga sa mga variable, ang isang klase ay magiging isang object. Ang iba't ibang mga halagang binigyan ng parehong klase ay nagreresulta sa iba't ibang mga bagay; iyon ay, ang iba't ibang mga bagay ay maaaring magkapareho ng klase ngunit may magkakaibang mga halaga. Ang paglikha ng isang bagay mula sa isang klase ay kilala rin bilang instantiating ng bagay.

Ang term vector ay naglalarawan sa isang klase. Ang isang bagay na nilikha mula sa isang vector ay may isang pangalan na pinili ng programmer.

Ang isang pagpapaandar na kabilang sa isang klase ay kinakailangan upang masimulan ang isang bagay mula sa klase. Sa C ++, ang pagpapaandar na iyon ay may parehong pangalan sa pangalan ng klase. Iba't ibang mga bagay na nilikha (instantiated) mula sa klase ay may natatanging mga pangalan na ibinigay sa bawat isa sa kanila ng programmer.

Ang paglikha ng isang bagay mula sa isang klase ay nangangahulugang pagbuo ng object; nangangahulugan din ito ng pag-uudyok ng bagay.

Ang Klase ng Vector

Ang klase ng vector ay natukoy na at nasa aklatan. Upang magamit ang vector class, dapat isama ng isang programmer ang vector header sa file na may sumusunod na preprocessing directive:

Kapag naisama ang header, ang lahat ng mga tampok sa vector (mga kasapi ng data at mga pagpapaandar ng miyembro) ay naa-access. Upang magamit ang bilang ng bagay upang maglabas ng data sa terminal (console), dapat isama rin ang header ng bagay. Upang magsulat ng isang programa sa vector, bilang isang minimum, ang mga sumusunod na header ay dapat na isama:

Instantiating isang Vector

Sa itaas ay ang deklarasyon ng isang array na may pangalang foo at ang bilang ng mga elemento 10. Ito ay isang hanay ng mga integer. Ang pagdeklara ng isang vector ay pareho. Para sa isang vector, ang bilang ng mga elemento ay opsyonal, dahil ang haba ng vector ay maaaring tumaas o mabawasan.

Sa puntong ito ng programa, ang klase ng vector ay natukoy na sa silid-aklatan, at isinama ang header. Maaaring maitaguyod ang vector tulad ng sumusunod:

Dito, ang vector ay ng pagpapaandar ng espesyal na konstruktor. Ang uri ng data na hahawak ng vector ay int, sa mga bracket ng anggulo. Ang term na vtr ay ang pangalan na pinili ng programmer para sa vector. Sa wakas, 8, sa panaklong, ang pansamantalang bilang ng mga integer na magkakaroon ng vector.

Ang term std ay nangangahulugang standard na namespace. Ang term na ito ay dapat na sundan ng isang dobleng colon, sa kontekstong ito. Kahit sino ay maaaring magsulat ng kanilang sariling vector class library at gamitin ito. Gayunpaman, ang C ++ ay mayroon nang isang pamantasang aklatan na may karaniwang mga pangalan, kabilang ang vector. Upang magamit ang isang pamantayang pangalan, ang pamantayang pangalan ay dapat na mauna sa std ::. Upang maiwasan ang pag-type std :: bawat oras sa programa para sa isang karaniwang pangalan, ang file ng programa ay maaaring magsimula tulad ng sumusunod:

Pag-overload ng isang Pag-andar

Kapag ang dalawa o higit pang magkakaibang mga lagda ng pag-andar ay may parehong pangalan, ang pangalan na iyon ay sinasabing sobra ang karga. Kapag ang isang pagpapaandar ay tinawag, ang bilang at uri ng mga argumento ay tumutukoy kung aling pagpapaandar ang naisakatuparan.

Bumubuo ng isang Vector

Ang pagbuo ng isang vector ay nangangahulugang instantiating (paglikha) ng isang vector object. Ang pagpapaandar ng tagapagbuo ay sobrang karga tulad ng sumusunod:

pangalan ng vector

Lumilikha ito ng isang vector ng haba na zero at i-type ang T. Ang sumusunod na pahayag ay lumilikha ng isang vector ng zero na haba ng uri na float na may pangalang vtr:

pangalan ng vector (n)

Lumilikha ito ng isang vector na may n mga elemento ng uri ng T. Ang isang pahayag para sa vector na ito na may apat na mga elemento ng float ay ang mga sumusunod:

pangalan ng vector (n, t)

Lumilikha ito ng isang vector ng mga n elemento na pinasimulan sa halagang t. Ang sumusunod na pahayag ay lumilikha ng isang vector ng 5 mga elemento, kung saan ang bawat elemento ay may halagang 3.4:

Pagbuo gamit ang Initialization

Ang isang vector ay maaaring itayo (nilikha) at gawing simula sa parehong oras, sa isa sa mga sumusunod na dalawang paraan:

O kaya naman

Tandaan na walang mga panaklong pagkatapos lamang ng pangalan ng object. Ginamit ang mga magulang pagkatapos lamang ng pangalan ng bagay na dapat magkaroon ng listahan ng inisyal, tulad ng sumusunod:

Ang isang vector ay maaaring maitayo at isimulan sa paglaon kasama ang listahan ng inisyal. Sa kasong ito, hindi gagamitin ang panaklong:

vector V2 (V1)

Ito ay isang tagatayo ng kopya. Lumilikha ito ng isang vector V2 bilang isang kopya ng vector V1. Ang sumusunod na code ay naglalarawan nito:

Pagtatalaga ng isang Vector habang Konstruksiyon

Sa panahon ng pagtatayo, ang isang walang laman na vector ay maaaring malikha habang ang isa pa ay nakatalaga dito, tulad ng sumusunod:

Ang pangalawang pahayag ay katumbas ng:

Const Vector

Ang isang Const vector ay isang vector na ang mga elemento ay hindi mababago. Ang mga halaga sa vector na ito ay read-only. Kapag nilikha, lilitaw ang vector tulad ng sumusunod:

Sa ganitong uri ng vector, walang elemento na maaaring idagdag o alisin. Bukod dito, walang halaga na mababago.

Bumubuo sa Iterator

Nagbibigay ang isang template ng isang pangkaraniwang representasyon para sa isang uri ng data. Ang isang iterator ay nagbibigay ng isang pangkaraniwang representasyon ng pag-scan sa pamamagitan ng mga halaga ng isang lalagyan. Ang syntax upang lumikha ng isang vector na may isang iterator ay ang mga sumusunod:

Bumubuo ito ng isang vector para sa saklaw [una, huling) gamit ang tinukoy na tagapaglaan, na tatalakayin sa paglaon sa artikulong ito.

Pagsira sa isang Vector

Upang sirain ang isang vector, payagan lamang itong lumabas sa saklaw at sirain ay awtomatikong hawakan.

Kapasidad ng Vector

size_type kapasidad () const noexcept

Ang kabuuang bilang ng mga elemento na maaaring hawakan ng vector nang hindi nangangailangan ng reallocation ay ibinalik ng pagpapaandar ng miyembro ng kapasidad. Ang isang segment ng code para dito ay ang mga sumusunod:

Ang output ay 4.

reserba (n)

Ang memorya ng puwang ay hindi palaging malayang magagamit. Ang ekstrang puwang ay maaaring maipareserba nang maaga. Isaalang-alang ang sumusunod na segment ng code:

Ang output ay 6. Kaya, ang labis na puwang na nakalaan ay 6 - 4 = 2 na mga elemento. Ang function ay nagbabalik walang bisa.

laki () const noexcept

Ibinabalik nito ang bilang ng mga elemento sa vector. Inilalarawan ng sumusunod na code ang pagpapaandar na ito:

Ang output ay 4.

Lumiit para magkasya()

Matapos bigyan ng labis na kapasidad ang isang vector na may pag-andar ng reserba (), ang vector ay maaaring sukatin pababa upang magkasya sa orihinal na laki nito. Ang sumusunod na code ay naglalarawan nito:

Ang output ay 4 at hindi 6. Ang function ay nagbabalik walang bisa.

baguhin ang laki (sz), baguhin ang laki (sz, c)

Nagbabago ang laki ng vector. Kung ang bagong sukat ay mas maliit kaysa sa dating laki, kung gayon ang mga elemento patungo sa dulo ay nabura. Kung ang bagong laki ay mas mahaba, pagkatapos ang ilang default na halaga ay idinagdag sa pagtatapos. Upang magkaroon ng isang partikular na idinagdag na halaga, gamitin ang function na baguhin ang laki () na may dalawang mga argument. Ang sumusunod na segment ng code ay naglalarawan ng paggamit ng dalawang pag-andar na ito:

Ang output ay ang sumusunod:

Ang mga pag-andar ay bumalik na walang bisa.

walang laman () const noexcept

Ang pagpapaandar na ito ay nagbabalik ng 1 para sa totoo kung walang mga elemento sa vector at 0 para sa maling kung ang vector ay walang laman. Kung ang isang vector ay may 4 na lokasyon para sa isang partikular na uri ng data, tulad ng float, nang walang anumang float na halaga, kung gayon ang vector na iyon ay hindi walang laman. Ang sumusunod na code ay naglalarawan nito:

Ang output ay ang sumusunod:

Pag-access ng Elemento ng Vector

Ang isang vector ay maaaring maging sub-scripted (index) tulad ng isang array. Nagsisimula ang pagbibilang ng index mula sa zero.

vectorName [i]

Ang operasyon vectorName [i] ay nagbabalik ng isang sanggunian sa elemento sa i^ikaindex ng vector. Ang mga sumusunod na code ay naglalabas ng 3.3 para sa itaas na vector:

vectorName [i] const

Ang pagpapatakbo vectorName [i] const ay naisakatuparan sa halip na vectorName [i] kapag ang vector ay isang pare-pareho na vector. Ginagamit ang operasyong ito sa sumusunod na code:

Ang expression ay nagbabalik ng isang pare-pareho na sanggunian sa i^ikaelemento ng vector.

Pagtatalaga ng isang Halaga sa Subscript

Ang isang halaga ay maaaring italaga sa isang hindi pare-pareho na vector, tulad ng sumusunod:

Ang output ay 8.8.

vectorName.at (i)

ang vectorName.at (i) ay tulad ng vectorName [i], ngunit ang vectorName.at (i) ay mas maaasahan. Ipinapakita ng sumusunod na code kung paano dapat gamitin ang vector na ito:

vectorName.at (i) const

ang vectorName.at (i) const ay tulad ng vectorName [i] const, ngunit ang vectorName.at (i) Const ay mas maaasahan. ang vectorName.at (i) Const ay naisakatuparan sa halip na vectorName.at (i) kapag ang vector ay isang pare-pareho na vector. Ginamit ang vector na ito sa sumusunod na code:

Pagtatalaga ng isang Halaga gamit ang () Pag-andar

Ang isang halaga ay maaaring italaga sa isang hindi pare-pareho na vector na may function na (), tulad ng sumusunod:

Ang output ay 8.8.

May problema sa Sub-Scripting

Ang problema sa sub-scripting (indexing) ay kung ang index ay wala sa saklaw, zero ay maaaring ibalik o isang error ay maaaring maisyu sa run-time.

harap ()

Nagbabalik ito ng isang sanggunian sa unang elemento ng vector nang hindi inaalis ang elemento. Ang output ng sumusunod na code ay 1.1.

Ang sangkap ay hindi tinanggal mula sa vector.

harap () const

Kapag ang pagbuo ng vector ay naunahan ng const, ang expression na harap () const ay naisagawa sa halip na harap (). Ginagamit ito sa sumusunod na code:

Ang isang pare-pareho na sanggunian ay naibalik. Ang sangkap ay hindi tinanggal mula sa vector.

likod ()

Nagbabalik ito ng isang sanggunian sa huling elemento ng vector nang hindi inaalis ang elemento. Ang output ng sumusunod na code ay 4.4.

likod () const

Kapag ang pagbuo ng vector ay naunahan ng const, ang expression na pabalik () const ay naisakatuparan sa halip na pabalik (). Ginagamit ito sa sumusunod na code:

Ang isang pare-pareho na sanggunian ay naibalik. Ang sangkap ay hindi tinanggal mula sa vector.

Pag-access ng Data ng Vector

data () walang eksep; data () const noexcept;

Ang alinman sa mga ito ay nagbabalik ng isang pointer tulad na ang [data (), data () + laki ()) ay isang wastong saklaw.

Masasaklaw ito nang mas detalyado sa paglaon sa artikulo.

Bumabalik na Iterators at Vector

Ang isang iterator ay tulad ng isang pointer ngunit may higit na pag-andar kaysa sa isang pointer.

magsimula () walang eksep

Nagbabalik ng isang umuulit na tumuturo sa unang elemento ng vector, tulad ng sa sumusunod na segment ng code:

Ang output ay 1.1. Tandaan na ang deklarasyong tumatanggap ng iterator ay idineklara. Ang iterator ay dinepresenta sa isang expression ng pagbabalik upang makuha ang halaga sa parehong paraan na ang isang pointer ay na-disferferensya.

simulan () const noexcept;

Nagbabalik ng isang umuulit na tumuturo sa unang elemento ng vector. Kapag ang pagbuo ng vector ay naunahan ng const, ang expression na magsisimula () const ay naisakatuparan sa halip na magsimula (). Sa ilalim ng kondisyong ito, ang katumbas na elemento sa vector ay hindi maaaring mabago. Ginagamit ito sa sumusunod na code:

Ang output ay 1.1. Tandaan na ang Const_iterator ay ginamit sa oras na ito sa halip na iterator lamang upang matanggap ang naibalik na umuulit.

magtapos () walang eksep

Nagbabalik ng isang umuulit na tumuturo kaagad na lampas sa huling elemento ng vector. Isaalang-alang ang sumusunod na segment ng code:

Ang output ay 0, na walang kahulugan, dahil walang kongkretong elemento na lampas sa huling elemento.

pagtatapos () const noexcept

Nagbabalik ng isang umuulit na tumuturo kaagad na lampas sa huling elemento ng vector. Kapag ang pagbuo ng vector ay naunahan ng const, ang expression na end () const ay naisagawa sa halip na wakasan (). Isaalang-alang ang sumusunod na segment ng code:

Ang output ay 0. Tandaan na ang Const_iterator ay ginamit sa oras na ito sa halip na iterator lamang upang matanggap ang naibalik na iterator.

Baliktarin ang Iteration

Posibleng magkaroon ng isang umuulit na umuulit mula sa dulo hanggang bago ang unang elemento.

rbegin () walang eksep

Nagbabalik ng isang umuulit na tumuturo sa huling elemento ng vector, tulad ng sa sumusunod na segment ng code:

Ang output ay 4.4.

Tandaan na ang deklarasyong tumatanggap ng reverse iterator ay idineklara. Ang iterator ay dinepresenta sa isang expression ng pagbabalik upang makuha ang halaga sa parehong paraan na ang isang pointer ay na-disferferensya.

rbegin () const noexcept;

Nagbabalik ng isang umuulit na tumuturo sa huling elemento ng vector. Kapag ang pagbuo ng vector ay naunahan ng const, ang expression na rbegin () const ay naisagawa sa halip na rbegin (). Sa ilalim ng kondisyong ito, ang katumbas na elemento sa vector ay hindi maaaring mabago. Ang tampok na ito ay ginagamit sa sumusunod na code:

Ang output ay 4.4.

Tandaan na ang const_reverse_iterator ay ginamit sa oras na ito, sa halip na ang reverse_iterator lamang, upang matanggap ang naibalik na iterator.

mag-render () nang walang eksepto

Nagbabalik ng isang umuulit na tumuturo bago ang unang elemento ng vector. Isaalang-alang ang sumusunod na segment ng code:

Ang output ay 0, na walang kahulugan, dahil walang kongkretong elemento bago ang unang elemento.

render () const noexcept

Nagbabalik ng isang umuulit na tumuturo bago ang unang elemento ng vector. Kapag ang pagbuo ng vector ay naunahan ng const, ang expression rend () const ay naisakatuparan sa halip na rend (). Isaalang-alang ang sumusunod na segment ng code:

Ang output ay 0.

Tandaan na ang const_reverse_iterator ay ginamit sa oras na ito, sa halip na ang reverse_iterator lamang, upang matanggap ang naibalik na iterator.

Mga Tagabago ng Vector

Ang isang modifier na nagbabago sa vector ay maaaring tumagal o magbalik ng isang iterator.

a.hula (p, args)

Nagpapasok ng isang bagay ng uri ng T na itinayo na may std :: pasulong (args) ... bago p.

ipasok (iteratorPosition, halaga)

Nagpapasok ng isang kopya ng halaga sa iterator na posisyon ng vector. Ibinabalik ang iterator (posisyon) sa vector kung saan inilagay ang kopya. Ipinapakita ng sumusunod na code kung saan inilagay ang halaga:

Ang output ay: 20 25 30.

Tandaan na ang iterator ay advanced (nadagdagan) tulad ng isang pointer.

Ang isang listahan ng initializer ay maaari ding ipasok, tulad ng inilalarawan ng sumusunod na code:

Ang output ay: 20 25 28 30.

burahin (posisyon)

Inaalis ang isang elemento sa posisyon na itinuro ng iterator, pagkatapos ay ibabalik ang posisyon ng iterator. Ang sumusunod na code ay naglalarawan nito:

Ang output ay: 10 20 40

push_back (t), push_back (rv)

Ginamit upang magdagdag ng isang solong elemento sa dulo ng vector. Gumamit ng push_back (t) tulad ng sumusunod:

Ang output ay 5.5.

pop_back ()

Tinatanggal ang huling elemento nang hindi ito ibabalik. Ang laki ng vector ay nabawasan ng 1. Ang sumusunod na code ay naglalarawan nito:

Ang output ay 3.

a. palitan (b)

Maaaring mapalitan ang dalawang mga vector, tulad ng nakalarawan sa sumusunod na segment ng code:

Ang output ay:

Tandaan na ang haba ng isang vector ay nadagdagan, kung kinakailangan. Gayundin, ang mga halagang walang mga kapalit ay pinalitan ng ilang default na halaga.

malinaw ()

Inaalis ang lahat ng mga elemento mula sa vector, tulad ng inilalarawan ng sumusunod na code segment:

Ang output ay 0.

Pagkapantay at Mga Kaugnay na Operator para sa Mga Vector

Ang == Operator

Nagbabalik ng 1 para sa totoo kung ang dalawang mga vector ay may parehong sukat at ang mga kaukulang elemento ay pantay; kung hindi man, nagbabalik ito ng 0 para sa hindi totoo. Halimbawa:

Ang output ay 0.

Ang! = Operator

Ibinabalik ang 1 para sa totoo kung ang dalawang mga vector ay walang parehong sukat at / o ang mga kaukulang elemento ay hindi pantay; kung hindi man, nagbabalik ito ng 0 para sa hindi totoo. Halimbawa:

Ang output ay 1.

Ang