Ang isang array ay isang pangkat ng mga elemento ng parehong uri ng data. Maraming mga pag-andar ang ginaganap sa mga arrays alinman sa pangunahing programa o sa labas nito, sa mga pagpapaandar. Sa C ++, sa kaso ng mga pagpapaandar, kailangan nating ipasa ang mga ito. Ginagawa ito sa pamamagitan ng mga parameter bilang mga argumento. Ang mga argumento na ito ay maaaring may iba't ibang paraan, alinman sa malalaking mga array o sa pamamagitan ng array ng pointer. Sa tutorial na ito, sasakupin namin ang ilang pangunahing mga aspeto ng paglilipat ng array gamit ang iba't ibang mga parameter ng mga pag-andar.
Syntax
[Bumalik kauri] [pangalan ngpagpapaandar] (datauriarrayname[arraylaki]){
pagpapaandarkatawan
}
Halimbawa 1
Isaalang-alang ang isang halimbawa kung saan kailangan naming mai-print ang mga marka ng mga mag-aaral sa C ++ program. Ang print na ito ay kukuha sa isang hiwalay na pagpapaandar sa halip na sa pangunahing programa. Sa kaibahan, kukuha kami ng mga input sa pangunahing programa at ililipat ang mga halagang ito sa pagpapaandar bilang isang parameter. Isaalang-alang ang pagpapaandar. Sa parameter nito, mayroong isang variable na datatype variable na tatanggapin ang mga halaga ng isang array. Ang buong array ay idineklara dito. Ang mga marka ay ipapakita sa tulong ng para sa loop. Tulad ng sa mga array, kailangan namin ng mga loop upang makakuha ng pag-print mula sa kanila.
Ang paglipat patungo sa pangunahing pag-andar, idineklara namin ang isang array na may laki at halaga dito. Tulad ng kailangan nating tawagan ang pagpapaandar. Kaya ang pamamaraan ay isusulat namin ang pangalan ng pag-andar na may pangalan ng array sa parameter bilang isang argument. Hindi namin natukoy ang laki ng array.
Ipakita(marka);
Ang argument sa parameter ay nagpapahiwatig ng memorya ng address ng array. Sa parameter ng header ng pagpapaandar, ang int m [7] ay ginawang int * m. Nagsasama ito ng parehong address tulad ng orihinal na array. Kapag ginamit namin ang m [5] sa katawan ng pagpapaandar, gagamitin namin ang orihinal na array.
Walang bisa ang pagpapakita(int m[7] )
Sa operating system ng Linux, ang pagkuha ng output sa pamamagitan ng isang terminal ay nangangailangan ng ilang mga paunang kinakailangan upang mai-install. Kailangan nito ang isang tagatala upang mag-ipon at pagkatapos ay ipatupad ang code sa terminal ng command prompt. Ginagamit ang G ++ sa C ++ para sa pagtitipon.
$g ++ -o kayacode3 code3.c
$./code3
Kung saan –o ay ginagamit upang iimbak ang output mula sa pinagmulang file sa output file.
Mula sa output, maaari mong obserbahan na ang lahat ng mga bilang na pinasimulan sa array sa pangunahing pag-andar ay naipasa at ipinakita sa pamamagitan ng pagpapaandar ng display.
Halimbawa 2
Ang isa pang halimbawa tungkol sa array na dumadaan sa parameter ay ang pagpasa ng isang multidimensional na array sa pagpapaandar. Ang isang two-dimensional array (2d) ay ginagamit dito. Sa pangunahing pag-andar, kailangan naming simulan ang isang array.
Int array[hilera][haligi]Kasama sa pagpapasimula ng 2d array ang hilera at haligi. At ang kanilang order ay mapanatili sa buong programa. Ang 2d array ay pinasimulan na may dalawang numero sa mga braket. Tulad ng inilarawan namin ang 2 mga haligi sa pagsisimula.
Ipakita(sa isa);Gagamitin lamang namin ang pangalan ng array sa parameter bilang isang argument.
Ngayon ay makikita namin ang paggana ng pagpapaandar ng display. Tulad ng pag-andar ay nagsimula, kinakailangan ng isang variable ng array upang tanggapin ang isang array na ipinasa ng function na tawag sa pamamagitan ng pangunahing programa.
Walang bisa ang pagpapakita(int n[][2] )Sapilitan na banggitin ang bilang ng mga haligi. Sa paghahambing, hindi ito mahalaga sa kaso ng mga hilera. Iyon ang dahilan kung bakit naiwan namin ang mga row ng row na walang laman dito habang ginagamit namin para sa loop upang maipakita ang mga resulta. Ngunit sa kaso ng isang 2-dimensional na array, gumagamit kami ng isang pugad para sa loop. Naglalaman ito ng dalawa para sa mga pahayag na may 2 mga variable dito.
Maaari naming tingnan ang output sa pamamagitan ng paggamit ng parehong tagatala. Maaari mong makita ang mga resulta na ang bawat halaga ay ipinapakita nang hiwalay sa hilera at numero ng haligi.
Halimbawa 3
Ang halimbawang ito ay medyo hindi magkakaiba sa mga nauna. Sa halimbawang ito, binabanggit namin ang laki ng array sa parameter ng call call. At sa pagdeklara ng pagpapaandar, ang isang variable ay ipinakilala din upang tanggapin ang laki ng isang array.
Simula mula sa pangunahing programa, ang isang array ay pinasimulan sa mga halaga.
Avg = getAverage(balanse,5);Ang resulta ay maiimbak sa avg variable. Sa halip na ipasa lamang ang pangalan ng array, ang laki ng array ay idinagdag din sa parameter.
Naglalaman din ang parameter ng variable na uri ng array at isang uri ng data ng integer upang matanggap ang laki ng array. Ang uri ng pangunahing programa ay int dahil makakatanggap ito ng isang integer na halaga mula sa pagpapaandar. Kung hindi man, ito ay walang bisa sa ibang mga kaso.
Ngayon makikita natin ang output. Ang halagang ito ay nakikita sa pamamagitan ng imahe na nakuha mula sa pagpapaandar.
Halimbawa 4
Ang halimbawang ito ay nauugnay sa pagtukoy ng maximum na bilang sa array, sa katunayan, mula sa dalawang mga array. Dito namin pinasimulan ang dalawang mga arrays Sa pangunahing programa. Ang parehong mga arrays ay hiwalay na ipinasa sa pag-andar sa magkakahiwalay na mga tawag sa pag-andar
printMax(arr1);printMax(arr2);
kung saan ang printMax ay ang pangalan ng pagpapaandar at arr ay ang array. Ang resulta ay hindi babalik mula sa pagpapaandar at ipapakita doon. Para sa loop ay kalkulahin ang maximum na bilang sa parehong mga arrays. Ginamit ang If-statement sa loob ng for loop. Ang header ng pagpapaandar ay:
walang bisa ang printMax(int arr[5]) 
Dahil ang parehong mga arrays ay naglalaman ng iba't ibang mga halaga, ang parehong mga resulta ay magkakaiba.
Halimbawa 5
Ang halimbawang ito ay ang buod ng lahat ng uri ng mga arrays na dumadaan sa mga parameter. Maaaring ito ay sukat, walang sukat o pointer arrays. Isaalang-alang namin sila.
Sa pangunahing programa, ang bawat pag-andar ay idineklara muna. Maaari mong ituro ang pagkakaiba sa kanilang deklarasyon.
Int sum1(int tmp[5]);Int sum2(int tmp[]);
Int sum3(int*tmp);
Ang tatlong mga arrays na ito ay naglalarawan na ang mga arrays ay maaaring pumasa sa pagkakaroon ng mga parameter na ito sa pagpapaandar.
Pagkatapos ng pagsisimula ng pagpapaandar, mayroon kaming pangunahing programa kung saan ipinahayag ang array. Hindi tulad ng nakaraang halimbawa, ang isang array ay pinasimuno sa halip na dalawa, ngunit ipinasa ito sa tatlong magkakaibang paraan. Ngayon makikita natin ang mga tawag na pagpapaandar na ginawa dito.
Kabuuan = kabuuan1(benta);Kabuuan = kabuuan2(benta);
Kabuuan = sume3(benta);
Ang output ay ipinapakita sa pangunahing pagpapaandar, kaya't ang isang variable ay idineklarang tatanggapin ang halagang ibinalik ng pagpapaandar. Mula sa lahat ng tatlong mga tawag sa pagpapaandar, maaari mong makita na dito ang mga parameter ay pareho. Naglalaman lamang ang bawat array ng pangalan ng isang array. Ngunit ang mga parameter ng pagpapaandar na tumatanggap ng array ay magkakaiba.
Ang panloob na katawan ng lahat ng tatlong mga pagpapaandar ay pareho, tulad ng kabuuan ng lahat ng mga numero ay kinakalkula mula sa paggamit ng Para sa loop. Ang pamamaraan at ang mga halaga ng array ay pareho; mayroon lamang diskriminasyon sa pagitan ng mga parameter ng mga pagpapaandar. Samakatuwid, napatunayan na maaari kaming gumamit ng iba't ibang mga pamamaraan upang tanggapin ang isang array o gumanap ng parehong pag-andar, at ang sagot ay pareho. Maaari naming kumpirmahin ito sa pamamagitan ng pagsuri sa output. Gamit ang parehong pamamaraan ng pagtitipon, makukuha namin ang output na ipinakita sa imaheng naidakip sa ibaba.
Maaari mong makita na ang sagot ay pareho para sa lahat ng tatlong mga pagpapaandar na ginamit.
Konklusyon
Sa artikulong ito, malalaman ng gumagamit ang tungkol sa pagdaan na pamamaraan ng isang array sa mga parameter. Maaaring hawakan ang mga array sa maraming mga kaso pagdating sa pagbabalik ng halaga o pagpasa nito sa mga argumento.