Narito ang laki ng isang array o ang haba ng isang array ay 6. At ang kabuuang sukat ng array na itatalaga ay hindi ipinakita. Ang tunay na laki ay nakuha sa pamamagitan ng paglalapat ng iba't ibang mga operasyon. Ang mga pagpapatakbo na ito ay ginagamit sa artikulong ito upang makuha ang laki ng isang array.
Halimbawa 1
Sa ilustrasyong ito, gagamitin namin ang konsepto ng pagsisimula () at pagtatapos (). Sa pamamagitan ng pamamaraang ito, madaling malalaman ang laki ng isang array. Ito ang dalawang silid-aklatan na kilala sa karaniwang mga silid aklatan. Ang dalawang pag-andar na ito ay nagbabalik ng mga iterator na nagpapakita ng paunang at nagtatapos na mga punto ng array. Simula mula sa header, gumagamit kami ng isang array library. Isasama nito ang lahat ng mga pagpapaandar na nauugnay sa array. Sa pangunahing pag-andar, pinasimulan namin ang isang array na mayroong mga halaga ng integer.
Gastos<<……….<<magtapos(sa)-begib(sa)<<
Dito hindi namin nabanggit ang laki ng array. Sa display statement kasunod ng cout, mayroon kaming mga end () at simulang () function. Ang hindi pagkakapareho sa pagitan ng dalawang mga pag-andar ay magpapakita sa amin ng laki ng isang array. Sa mga parameter ng mga pagpapaandar na ito, naipasa na namin ang array. Sa pamamagitan nito, matutukoy ang aktwal na laki. Ang nagresultang halaga mula sa mga pagpapaandar na ito ay direktang ipinapakita.
Gumalaw ngayon patungo sa output. Ipapatupad namin ang mga programang ito sa Linux, kaya kailangan namin ang paglahok ng terminal ng Ubuntu. Habang gumagamit kami ng C ++ code, kaya kailangan naming mag-ipon ng code sa pamamagitan ng tagatala. Iyon ang tagatala ng G ++. Pagkatapos maipon ang code, isasagawa namin ito. Ipinapakita ng mga utos sa ibaba ang diskarte ng output na ginamit namin.
$ g++ -o code2 code2.c$./code2
Maaari mo nang makita ang output. Ang isa pang katulad na halimbawa sa kaso ng std ay ang pagpapaandar ng distansya. Sa distansya na ito ay kinakalkula sa pamamagitan ng paggamit ng mga function ng pagsisimula () at pagtatapos (). Nakumpleto ito sa pamamagitan ng paggamit ng mga pagpapaandar na ito sa std.
Int n=oras:: distansya(oras::magsimula(arr),oras::magtapos(arr)); 
Ang output ay nakuha sa pahayag ng cout. Upang makita ang talaan, gamitin muli ang tagatala upang maipatupad ang code.
Dito mo makikita na ang nais nating output ay nakuha.
Halimbawa 2
Ang halimbawang ito ay nauugnay sa paggamit ng pag-andar ng sizeof () sa C ++ code, dahil ibinalik ng halagang ito ang aktwal na laki ng data sa anyo ng mga byte. Bukod dito, nakikipag-usap din ito sa pagbabalik ng bilang ng mga byte na ginagamit upang mag-imbak ng isang array. Sa madaling salita, Sa halimbawang ito, ang unang hakbang ay ang pagpapasimula ng isang array nang hindi idedeklara ang laki ng isang array. ang syntax na ginamit para sa laki ng () pagpapaandar ay:
Int al= sukat ng(arr)/sukat ng(arr[0]);Kung saan arr ay ang array. Ipinapakita ng arr [0] ang index ng mga elemento sa array.
Kaya't ang pahayag na ito ay nagpapahiwatig na ang laki ng array ay nahahati sa laki ng lahat ng mga elemento na naroroon, isa-isa. Nakakatulong ito sa pagkalkula ng haba. Gumamit kami ng isang variable na integer upang matanggap at maiimbak ang return ng halaga mula sa pagpapaandar.
Makukuha namin ang output dito mula sa prompt ng utos ng parehong pamamaraan ng pagtitipon-pagpapatupad.
Ipinapakita ng output ang laki ng array, na nagpapahiwatig ng bilang ng mga elemento na naroroon dito, kung saan ay 6.
Halimbawa 3
Kasama sa halimbawang ito ang paggamit ng laki () na pagpapaandar. Ang pagpapaandar na ito ay inilalagay sa karaniwang silid aklatan, STL. Ang paunang hakbang sa pangunahing programa ay ang deklarasyon ng array. Dito naglalaman din ang pangalan ng array ng laki at halaga ng integer. Ibinabalik din ng pamamaraang ito ang resulta nang direkta sa pahayag ng output.
Gastos<<....<<arr.laki()<<Kung saan ang 'arr' ay ang array, upang makuha ang resulta o ma-access ang pagpapaandar, kailangan namin ang pangalan ng array na may laki ng function.
Upang maipakita ang resulta, ginagamit namin ang compiler ng g ++ upang maipon at ipatupad ang resulta.
Mula sa output, maaari mong makita na ang resulta ay ang aming ninanais na nagpapakita ng aktwal na laki ng array.
Halimbawa 4
Ang laki ng isang array ay maaari ding makuha sa pamamagitan ng paggamit ng mga payo habang itinatago ng mga payo ang address / lokasyon ng halaga ng variable. Isaalang-alang ngayon ang nasa ibaba na binigyan ng isang halimbawa.
Ang paunang hakbang ay upang simulan ang isang array tulad ng dati. Pagkatapos ang pointer ay gumagana para sa laki ng array.
Int len= *(&array+ 1)- array;Ito ang pangunahing pahayag na gumagana bilang isang pointer. * ay ginagamit upang hanapin ang posisyon ng anumang elemento sa isang array, samantalang ang & operator ay ginagamit upang makuha ang halaga ng lokasyon na nakuha sa pamamagitan ng pointer. Ito ang paraan na nakakakuha kami ng laki ng array mula sa mga payo. Ang resulta ay ipinapakita sa pamamagitan ng terminal. Ang sagot ay pareho. Tulad ng laki ng nabanggit na array ay nakasaad bilang 13.
Halimbawa 5
Sa halimbawang ito, ginamit namin ang ideya ng pagbawas ng argument ng template. Ang isang argument na template ay isang parameter ng isang espesyal na uri. Ginagamit ito upang pumasa sa isang argument ng anumang uri, tulad ng mga regular na pag-andar na maaaring maipasa bilang isang argument.
Kapag ang isang array ay naipasa bilang isang parameter, ito ay na-convert sa isang pointer upang ipakita ang address. Upang makuha ang haba ng tukoy na array, ginagamit namin ang diskarteng ito ng pagbawas ng template ng argument. Ang Std ay isang maikling form ng pamantayan.
Isinasaalang-alang ang ibinigay na isang halimbawa, nagpakilala kami ng isang klase ng template na ginamit upang makuha ang laki ng array. Ito ay isang default na built-in na klase na naglalaman ng lahat ng mga pagpapaandar ng mga argumento ng template.
Constexpr std: : size_tlaki(ConstT(&array)[N])noexcept{bumalik kaN;
}
Ito ay isang pare-pareho na linya sa konseptong ito. Ang output ay nakuha nang direkta sa pahayag ng cout.
Mula sa output, maaari mong makita na nakuha namin ang aming ninanais na output: ang laki ng array.
Halimbawa 6
Gumagamit kami ng std :: vector upang makuha ang laki ng array sa programa. Ito ay isang uri ng lalagyan; ang pagpapaandar nito ay upang mag-imbak ng mga pabagu-bagong array. Gumagana ito sa iba't ibang mga pamamaraan para sa iba't ibang mga operasyon. Upang magawa ang halimbawang ito, gumamit kami ng isang vector library na may kasamang lahat ng mga pagpapaandar ng vector dito. Inihahayag din nito ang mga pahayag sa cin, cout, endl, at vector na gagamitin sa programa. Ang isang array ay pinasimulan muna sa programa. Ang output ay ipinapakita sa pahayag ng cout ayon sa laki ng vector.
Gastos<<laki ng vector: <<int_arraylaki() <<endl; 
Ngayon makikita natin ang output mula sa terminal ng Ubuntu. Ang laki ng array ay tumpak sa mga elementong naroroon.
Konklusyon
Sa tutorial na ito, gumamit kami ng ibang diskarte upang makuha ang haba ng haba o laki. Ang ilan ay built-in na pag-andar, samantalang ang iba ay ginagamit nang manu-mano.