Sa artikulong ito, titingnan natin ang calloc() function at kung paano ito matagumpay na magagamit sa C++.
Ano ang calloc() Function?
Ang calloc() function ay isang memory allocation function sa C++ programming. Ito ay ginagamit upang maglaan ng isang bloke ng memorya para sa isang array o hanay ng mga variable. Ang calloc() function ay tulad ng malloc() function, maliban kung itinatakda din nito ang inilalaan na memorya sa mga zero sa simula. Tinitiyak nito na ang inilalaan na memorya ay sinisimulan sa isang kilalang halaga, na kapaki-pakinabang kapag nagtatrabaho sa mga array at istruktura.
Ang syntax para sa calloc() function ay ang mga sumusunod:
walang bisa * calloc ( laki_t nmemb , laki_t laki )
Ang function ay tumatagal ng dalawang argumento: nmemb at laki . Ang nmemb Tinutukoy ng argumento ang bilang ng mga elemento sa array na inilalaan, habang ang laki Tinutukoy ng argumento ang laki ng bawat elemento sa mga byte.
Gayundin, kung magtagumpay ang paglalaan ng memorya, ang calloc() function ay nagbabalik ng isang null pointer, kung hindi, ito ay nagbabalik ng isang pointer sa simula ng bagong nabuo na bloke ng memorya. Upang maiwasan ang pagtagas ng memorya, ang memorya na inilalaan ng calloc() dapat alisin gamit ang libre() paraan kapag hindi na ito kinakailangan.
Paano Gamitin ang Calloc() Function sa C++?
Upang gamitin calloc() function sa C++, sundin ang mga hakbang na ibinigay sa ibaba:
Hakbang 1: Isama ang kinakailangang header file para sa calloc() function, na
Hakbang 2: Pagkatapos ay magdeklara ng pointer variable ng nais na uri ng data.
Hakbang 3: Pagkatapos nito gamitin ang calloc() function upang maglaan ng memorya at simulan ito sa 0.
Hakbang 4: Gamitin ang nakalaan na memorya kung kinakailangan.
Hakbang 5: Kapag tapos ka nang gamitin ang inilalaan na memorya, palayain ito gamit ang libre() function.
Ang sumusunod na halimbawa ay nagpapakita ng calloc() pagpapatupad ng function sa C++.
#include#include
gamit ang namespace std ;
int pangunahing ( ) {
int * ptr ;
ptr = ( int * ) calloc ( 6 , sukat ng ( int ) ) ;
kung ( ! ptr ) {
cout << 'Nabigo ang Paglalaan ng Memorya' ;
labasan ( 1 ) ;
}
cout << 'Pagsisimula ng mga halaga...' << endl
<< endl ;
para sa ( int i = 0 ; i < 6 ; i ++ ) {
ptr [ i ] = i * 3 ;
}
cout << 'Mga inisyal na halaga.' << endl ;
para sa ( int i = 0 ; i < 6 ; i ++ ) {
cout << * ( ptr + i ) << endl ;
}
libre ( ptr ) ;
bumalik 0 ;
}
Sa code sa itaas, isang integer pointer ptr idineklara muna. Ang memorya ay pagkatapos ay inilalaan para sa 6 integer gamit calloc(), na ang memorya ay pinasimulan ng 0. Ang sizeof(int) Ang function ay ginagamit upang kalkulahin kung gaano karaming memorya ang kinakailangan upang mag-imbak ng mga integer. Ang paglalaan ng memorya ay sinuri para sa mga error upang matiyak ang tagumpay. Kung hindi, magtatapos ang program at may ipapakitang mensahe ng error.
Ang inilalaan na memorya ay pinasimulan gamit ang mga numerong nakuha sa pamamagitan ng pagpaparami 'i*3' gamit ang para sa loop. Ang mga halagang pinananatili sa inilalaang memorya ay naka-print gamit ang isang segundo para sa loop at pointer arithmetic na may *(ptr + i) . Sa huli, ang memorya na dynamic na inilaan ay inilabas sa pamamagitan ng pagtawag sa libre() function, na humihinto sa pagtagas ng memorya. Bilang tanda na matagumpay na tumakbo ang programa, nagbabalik ito ng 0.
Output
Konklusyon
Sa C++, ang calloc() Ang function ay kapaki-pakinabang para sa dynamic na paglalaan ng memorya. Ito ay hindi lamang naglalaan ng memorya ngunit ito rin ay nagse-zero, na kapaki-pakinabang kapag nagtatrabaho sa mga array at istruktura. Pag-unawa kung paano gamitin calloc() epektibo ay mahalaga para sa pag-iwas sa mga pagtagas ng memorya at pagtiyak ng tagumpay sa pagpapatupad ng programa. Maaaring ligtas na magamit ng mga developer ang calloc() paraan sa kanilang mga programang C++ sa pamamagitan ng pagsunod sa mga tagubiling ibinigay sa artikulong ito.