Gumamit ng Mga Puro upang Maibalik ang Static Array
Kapag gumagamit kami ng isang normal na array, may mga pagkakataong magkaroon ng ilang uri ng hindi normal na mga resulta. Upang maiwasan ito, gumagamit kami ng isang static na array sa aming C ++ code. Unawain natin ang halimbawa na ginamit natin. Sa pagpapaandar na ito, idineklara namin ang isang array na may 5 halaga ang uri ng pagbabalik tulad ng nabanggit dito.
Int * function ()
Tulad ng halaga ay magiging isang uri ng integer, kaya naka-tag ito bilang int sa halimbawa sa ibaba. Tulad ng ipinakilala namin ang pagpapaandar bilang isang pointer, ang pagpapaandar ay magiging isang uri ng pointer. Matapos ipasok ang mga halaga, ang isang array ay ibabalik sa pangunahing programa.
Sa pangunahing programa, gumawa kami ng isang tawag sa pag-andar. Upang tanggapin ang halagang ibinalik mula sa pagpapaandar, gagamit kami ng isang variable na integer. Kapag naibalik ang array, madali nating ma-access ang mga halaga nito. Ang mga halaga ay mai-print nang manu-mano.
Int*pointer=pagpapaandar();Ang layunin ng pointer ay upang mahanap ang item na naroroon sa index ng isa sa mga array. Sa madaling salita, ipinapakita nito ang address ng halaga sa array. Pagkatapos, gumagamit kami ng isang function na prototype na ibabalik ang pointer.
Upang makita ang output ng array na bumalik sa pamamagitan ng pag-andar, kailangan nating magkaroon ng access sa terminal ng Ubuntu sa kaso ng Linux. Dahil ito sa pag-access na ma-access sa pamamagitan ng Linux terminal. Sa Linux, kailangan namin ng tagatala upang patakbuhin ang mga code ng C ++ na nakasulat sa anumang text editor. Ang pagtitipong ito ay ginagawa sa pamamagitan ng G ++. Ginagamit ang -o upang iimbak ang output sa isang file. Dito, kailangan namin ang output file at ang source code file. Pagkatapos ng pagtitipon, isasagawa namin ang code:
$g ++ -o kayafile1 file1.c$./file1
Mula sa output, maaari nating makita ang array, na kung saan ay pinasimulan sa pagpapaandar, ay ipinapakita sa pangunahing pag-andar sa pamamagitan ng paggamit ng isang static na array, na-initialize nang manu-mano at sa pamamagitan ng mga payo.
Ibalik ang Dynamically Allocated Array Gamit ang Mga Puro
Maaaring ibalik ang mga array sa pamamagitan ng paggamit ng pabagu-bagong paglalaan. Ang mga array ay maaaring mailalaan sa pamamagitan ng paggamit ng salitang bago. Mananatili sila roon hanggang sa tanggalin namin ang mga ito nang mag-isa. Ang mga static array ay naayos sa laki, na nangangahulugang kailangan mong magbigay ng laki sa panahon ng pagsisimula. Kapag ang array ay nilikha, pagkatapos ito ay mahirap upang madagdagan ang laki sa run time o sa hinaharap. Ngunit sa kaso ng pabagu-bagong hanay, maaari kaming magdagdag ng higit pang mga item kahit kailan namin gusto dahil lumalaki ito habang inilalagay namin ang mga halaga dito. Kaya hindi namin kailangang tukuyin o tukuyin ang anumang laki.
Paglipat sa halimbawa na ginamit namin dito. Gumamit kami ng isang pabagu-bagong array kasama ang mga payo tulad ng sa nakaraang mga halimbawa, kung saan gumamit kami ng mga pointer na may static arrays.
Int*pagpapaandar()Pagkatapos ng pagdeklara ng pagpapaandar, ang mga array ay idineklara nang pabago-bago:
Int*array= bago int [100];Ang term na, bago, ay patuloy na ginagamit upang lumikha ng isang pabagu-bagong array. Gagawa kami ng mga pagpapatakbo sa array sa pamamagitan ng pagpasok ng mga halaga dito. Pagkatapos nito, ang array ay ibinalik sa pangunahing programa:
Ngayon, isaalang-alang ang pangunahing pagpapaandar. Namin ang tumawag sa pagpapaandar. Tulad ng pagbabalik ng array, nagdagdag kami ng variable ng uri ng integer ng pointer upang tanggapin ang halaga.
Int*pointer=pagpapaandar();Ang mga halagang naimbak sa array ay manu-manong nai-print. Ang output ay nakuha sa pamamagitan ng pamamaraang pag-ipon at pagpapatupad.
Ibalik ang Array Gamit ang Mga Istraktura
Ang mga istraktura ay ang mga lalagyan tulad ng mga arrays. Ngunit ang array ay naglalaman ng halaga ng parehong uri ng data nang paisa-isa. At sa kaso ng mga istraktura, naglalaman ang mga ito ng higit sa isang halaga ng uri ng data. Kumuha kami ng isang istraktura na nagngangalang sample. Dito, ang deklarasyon ng array ay nasa loob ng mga istraktura sa halip na mga pag-andar. Ang uri ng pagbabalik ay ang pangalan ng istraktura. Ang variable ng istraktura ay ibinalik sa pangunahing programa. Gumagamit ang istraktura ng salitang istruktura para sa deklarasyon.
Sample ng istraktura{
Int arr[100];
};
Matapos ang deklarasyon ng istraktura, gumamit kami ng isang pag-andar kung saan nilikha ang isang bagay ng istraktura. Gagamitin ang bagay na ito upang ma-access ang istraktura. Ang function na ito ay ibabalik ang object ng istraktura sa pangunahing pagpapaandar upang maaari naming mai-print ang array sa pamamagitan ng object na ito. Makukuha ng isang variable ang mga halaga sa variable. Ang halagang ito ay ang bilang ng integer kung saan ipasok namin ang mga halaga sa array. Tulad ng halimbawang ito, pumili kami ng 6 bilang ng numero. Kaya, ang mga numero ay ipinasok hanggang sa 6 sa array.
Istraktura sample func(intn) 
Ngayon, paglipat patungo sa pangunahing programa, lumikha kami ng isang bagay upang ma-access ang array sa pamamagitan nito:
Sample ng istraktura x; 
Pagkatapos ng pagsisimula ng bagay, isang halaga ay idinagdag sa variable hanggang sa nais naming maipasok ang mga numero sa array. Sa isang tawag na pagpapaandar, ipapasa namin ang halaga sa parameter:
X=pagpapaandar(n);Magkakaroon kami ng display sa pamamagitan ng paggamit ng for loop. Ang mga halaga ay ipinapakita sa pamamagitan ng bagay na idineklara sa simula ng pangunahing programa:
Ipinapahiwatig ng output na 6 na halaga ang ipinapakita sa resulta ng ipinasok namin ang 6 na numero sa programa.
Ibalik ang Array Gamit ang Std
Gumagamit ang C ++ ng maraming pamamaraan upang maibalik ang isang array mula sa pagpapaandar. Isa sa mga ito ay sa pamamagitan ng std :: array. Ito ay isang template ng istraktura. Nagbibigay din ang tampok na ito ng dalawa pang mga pagpapaandar na laki () at walang laman (). Ang isang pangalan ng array ay ibinalik na nagpapahiwatig na ang buong array ay naibalik sa pangunahing programa. Dito, magdagdag kami ng isang header file array. Bilang karagdagan sa library, naglalaman ito ng lahat ng mga pag-andar ng array.
# isama 
Dahil maibabalik namin ang buong array na may pangalan nito, kaya't sa pagdeklara ng isang pagpapaandar, gagamitin namin ang array bilang isang uri ng pagbabalik. Ang data ay ipinasok sa array. Pagkatapos nito, ibabalik ang array sa pangunahing programa. Ang paglipat patungo sa pangunahing pagpapaandar, tatanggapin ng isang variable ng array ang array kapag tinawag ang pagpapaandar.
arr=pagpapaandar();Muli, para sa loop ay gagamitin para sa pagpapakita ng mga halaga ng array. Pinagmasdan namin ang output mula sa imaheng ipinakita sa ibaba. Tulad ng ginamit namin na 10 laki, 0 na numero ang ipapasok. Samakatuwid, ipinapakita ang mga ito:
Ibalik ang Array Sa Pamamagitan ng Vector Container
Ang pamamaraang ito ay isang pabagu-bago na inilalaan na array. Tulad ng sa kasong ito, hindi na kailangang tukuyin ang laki ng array. Hindi namin kailangan ang anumang sukat ng parameter dito. Gamit ang halimbawang ito, kailangan naming magdagdag ng isang vector header sa silid-aklatan na naglalaman ng mga pagpapaandar ng vector.
Ang paglipat patungo sa pagpapaandar, kung saan ang uri ng pagbabalik ay isang int vector din at naglalaman din ng isang vector pointer bilang isang argument sa parameter. Ang isang array na may pangalang temp ay ipinakilala dito:
Vector<int>MultiplyArrayByTwo(Constvector<int> *arr)Ang function ay magpaparami ng mga elemento ng array sa pamamagitan ng dalawa sa pamamagitan ng paggamit ng tmp.push_back () function. Pagkatapos, ibalik ang tmp. Tatanggap ng isang variable na auto-type ang mga halaga ng array mula sa pagpapaandar. Naglalaman ang array ng mga item dito.
Ipinapakita ng output ang pagtatrabaho ng lalagyan ng vector.
Konklusyon
Sa nabanggit na artikulo, inilarawan namin ang limang pinaka-karaniwang ginagamit na pamamaraan upang ipaliwanag ang pag-andar ng pagbalik ng isang array mula sa pagpapaandar.