C Language Navigator ― Pinakamalakas na Mapagkukunan para sa Pagpapaunlad ng Sistema

Paliwanag sa malloc sa C: Batayan hanggang Advanced na Memory

Mga Pointer at Pamamahala ng Memorya
目次

1. Panimula

Kapag nagsimulang magsulat ng programa sa wikang C, kadalasan ay gumagamit ng mga array at iba pa para humawak ng memorya. Ngunit habang nagiging mas kumplikado ang programa, may mga pagkakataon na nais mong pamahalaan ang memorya nang mas flexible. Sa mga ganitong sitwasyon, ang tinatawag na “dynamic memory allocation” ay tumutulong. Ang malloc ay isang kilalang tampok nito, na nagbibigay-daan upang maglaan ng kinakailangang memorya nang dinamiko habang tumatakbo ang programa. Sa paghahambing, ang malloc ay parang “pagkain na niluluto matapos umorder”. Ang memorya na nakatakda nang maaga (tulad ng mga array) ay maihahalintulad sa “buffet style na pagkain”. Ino‑order mo lamang ang dami ng pagkain na gusto mo gamit ang malloc, at kapag natapos mo na, “ibababa mo ang pinggan” (paglaya ng memorya gamit ang free function) ang karaniwang daloy. Ngayon, tatalakayin natin nang detalyado ang malloc sa artikulong ito.

2. malloc Ano ang?

malloc ay pinaikling anyo ng “memory allocation (paglalaan ng memorya)”, isang function sa wikang C para dinamikong magreserba ng memorya. Sa panahon ng pagpapatakbo ng programa, naglalaan ito ng memorya ayon sa tinukoy na sukat at ibinabalik ang address ng simula nito. Sa ganitong paraan, maaaring gamitin ng programa ang kinakailangang dami ng memorya habang tumatakbo, na nagbibigay ng flexible na pamamahala ng memorya na mahirap gawin gamit ang mga array na may nakatakdang sukat. Sa aktwal na code, ginagamit ang malloc tulad ng sumusunod.
int *array = (int*)malloc(10 * sizeof(int));
Sa halimbawang ito, naglalaan ng 10 na elemento ng array na may uri ng integer. Ang mahalagang punto dito ay ang malloc ay nagbabalik ng address ng simula ng nareserbang memorya, kaya maaaring hindi tumugma ang uri nito nang direkta. Kaya karaniwan na i-cast ito sa kinakailangang uri. Sa itaas, ginamit ang (int*) upang i-cast sa pointer ng integer.
侍エンジニア塾

3. Pangunahing Paggamit ng malloc

Ngayon, tingnan natin nang mas detalyado ang paggamit ng malloc. Una, ang simpleng syntax ng malloc ay ang sumusunod.
void* malloc(size_t size);
Ang function na malloc ay tumatanggap ng laki ng memorya (sa byte) na nais i-allocate bilang argumento. Pagkatapos, nag-aallocate ito ng memory region na may sukat na iyon, at kung matagumpay, ibinabalik ang address ng simula ng region. Ang ibinabalik ay uri ng void*, ibig sabihin ay isang generic pointer na maaaring i-cast sa anumang uri. Halimbawa, ganito ang paggamit.
int *array = (int*)malloc(10 * sizeof(int));
Dito, ginagamit ang sizeof(int) upang alamin ang laki ng memoryang i-aallocate. Sa ganitong paraan, kahit sa ibang kapaligiran, makakakuha ka ng tamang sukat ng memorya. Kapag nagamit na ang na-allocate na memorya, mahalagang i-deallocate ito gamit ang function na free. Kung hindi ito i-deallocate, magdudulot ito ng tinatawag na memory leak.

4. Ang kahalagahan ng pag-release ng memorya gamit ang free()

Walang duda na kapaki-pakinabang ang dynamic na paglalaan ng memorya, ngunit may isang babala. Kailangan mong siguraduhing palayain ang memoryang nailaan mo. Kung hindi mo ito gagawin, magdudulot ito ng memory leak, at ang programa ay magsasayang ng malaking halaga ng memorya. Ang memoryang nailaan gamit ang malloc ay pinapalaya gamit ang free() tulad ng sumusunod.
free(array);
Ang memoryang hindi nailabas ay mananatiling bahagi ng mga mapagkukunan ng sistema hanggang sa matapos ang programa, at sa mga programang tumatakbo nang matagal, maaaring maging kritikal na problema ito. Sa madaling salita, kung hindi mo ibabalik nang maayos ang mga pinggan na hiniram mo gamit ang malloc sa pamamagitan ng free, magiging punong-puno ng pinggan ang kusina.

5. Kahalagahan ng Pag-check ng NULL

malloc function ay nagbabalik ng NULL kapag nabigong maglaan ng memorya. Halimbawa, kapag ang memoryang gustong i-allocate ay masyadong malaki at hindi kayang i-assign ng sistema. Kapag gumagamit ng malloc, laging i-check ang NULL na ito upang tiyakin na ang memorya ay matagumpay na na-allocate; ito ang ligtas na paraan ng pagsulat ng programa.
int *array = (int*)malloc(100000000 * sizeof(int));
if (array == NULL) {
    // Pagproseso kapag nabigo ang paglalaan ng memorya
    printf("Memory allocation failed.
");
    return 1;
}
Sa ganitong paraan ng pag-check, posible ang error handling para sa pagkabigo ng paglalaan ng memorya. Sa pagdaragdag ng kaunting safety measure sa code, maiiwasan mo ang malalaking problema sa hinaharap.

6. Pagkakaiba ng malloc at calloc

Sa C language, bukod sa malloc, may iba pang mga function para sa dynamic na paglalaan ng memorya. Isa sa mga ito ay ang calloc. Ang malloc at calloc ay napaka-magkatulad, ngunit may ilang mahahalagang pagkakaiba. Ang malloc ay naglalaan lamang ng memorya ayon sa tinukoy na sukat, at ang laman nito ay hindi pa na-initialize. Samantala, ang calloc ay naglalaan ng memorya at agad itong ini-initialize sa zero.

Paggamit ng calloc

int *array = (int*)calloc(10, sizeof(int));
Ang code na ito ay naglalaan ng 10 na elemento ng array na may uri ng integer, at ini-initialize ang bawat elemento sa zero. Ang pangunahing pagkakaiba sa malloc ay ang calloc ay tumatanggap ng dalawang argumento: “bilang ng mga elemento” at “laki ng bawat elemento”. Ang syntax na ito ay kapaki-pakinabang dahil kapag humahawak ng data na may maraming elemento tulad ng array, mas madaling maunawaan kung paano maglaan ng memorya. Depende sa sitwasyon kung alin ang dapat gamitin, ngunit kung kailangan ng initialization, kapaki-pakinabang ang calloc. Sa kabilang banda, kung hindi kailangan ng initialization o kung binibigyang-pansin ang performance, mas angkop ang malloc.

7. Praktikal na Halimbawa: Dynamic na Paglalaan ng String gamit ang malloc

Dito, titingnan natin ang aktwal na dynamic memory allocation ng string gamit ang malloc. Kapag naghawak ng mga string sa wikang C, karaniwang gumagamit ng mga array na may takdang sukat. Gayunpaman, kung ang haba ng string ay nalalaman lamang sa runtime o nais mong manipulahin ang string nang dynamic, kapaki-pakinabang ang malloc.
char *str = (char*)malloc(50 * sizeof(char));
if (str == NULL) {
    printf("Nabigong maglaan ng memorya.\n");
    return 1;
}
sprintf(str, "Kumusta, Mundo!");
printf("%s\n", str);
free(str);
Sa code na ito, dinadagdagan nang dynamic ang memorya para sa 50 na karakter, at inilalagay ang string na “Kumusta, Mundo!” sa nasabing lugar. Pagkatapos gamitin, huwag kalimutang i-release ang memorya gamit ang function na free. Sa pamamagitan ng paggamit ng malloc, posible ang flexible na pamamahala ng memorya na hindi magagawa ng mga array na may takdang sukat.

8. Paggamit ng malloc sa mga istruktura

Susunod, tingnan natin ang isang halimbawa ng paggamit ng malloc upang dinamiko na maglaan ng memorya para sa isang istruktura. Ang istruktura ay isang makapangyarihang uri ng data na maaaring pagsamahin ang maraming magkaibang uri ng data, at maaari ring pamahalaan ang memorya nito nang dinamiko.
typedef struct {
    int id;
    char *name;
} Person;

Person *p = (Person*)malloc(sizeof(Person));
if (p == NULL) {
    printf("Nabigong maglaan ng memorya.\n");
    return 1;
}
p->name = (char*)malloc(50 * sizeof(char));
sprintf(p->name, "John Doe");
p->id = 1;

printf("ID: %d, Pangalan: %s\n", p->id, p->name);

free(p->name);
free(p);
Sa code na ito, dinamiko naming inilaan ang memorya para sa istruktura na tinatawag na Person, at dininamiko ring inilaan ang memorya para sa member variable na name. Sa ganitong paraan, sa pamamagitan ng paggamit ng malloc sa bawat member ng istruktura kung kinakailangan, maaaring pamahalaan ang memorya nang flexible.

9. Mga karaniwang pagkakamali sa paggamit ng malloc

Sa paggamit ng malloc, talakayin din natin ang mga karaniwang pagkakamali na nagagawa ng mga baguhan. Sa pag-iwas sa mga pagkakamaling ito, makakagawa ka ng mas ligtas at mas epektibong programa.
  1. Nakalimutang i‑free ang memorya Kung nakalimutang i‑free ang memoryang dinynamic na na‑allocate gamit ang free(), magreresulta ito sa memory leak. Ito ay maaaring maging malaking problema lalo na sa mga programang tumatakbo nang matagal. Kahit gaano pa kasalimuot ang programa, gawing ugali na palaging i‑free ang na‑allocate na memorya.
  2. Pagwawalang‑bahala sa NULL check Madalas nakalimutan na kapag nabigo ang pag‑allocate ng memorya, magbabalik ito ng NULL. Kaagad pagkatapos ng pag‑allocate, siguraduhing magsagawa ng NULL check at mag‑implement ng error handling.
  3. Pag-access sa hindi pa na‑initialize na memorya Ang memoryang na‑allocate gamit ang malloc ay hindi pa na‑initialize. Kung gagamitin ito nang direkta, maaaring magdulot ito ng hindi inaasahang pag‑ugali. Lalo na kung kailangan ng initialization, isaalang‑alang ang paggamit ng calloc.

10. Buod

malloc ay isang makapangyarihang tool sa wikang C, na mahalaga kapag dinamikong naglalaan ng memorya. Gayunpaman, upang magamit nang tama ang kapangyarihan nito, kinakailangan ang matibay na pag-unawa at angkop na pamamahala ng memorya. Mula sa mga pangunahing paraan na ipinakilala dito hanggang sa aplikasyon sa mga istruktura at string, siguraduhing ilapat ito nang maayos sa praktika. Sa susunod na pagsusulat ng programa, huwag kalimutang mag-allocate ng memorya gamit ang malloc at ibalik ito nang maayos pagkatapos magamit! FAQ
  1. Kung hindi makapag-allocate ng memorya gamit ang malloc, ano ang dapat gawin? Kapag nabigo ang paglalaan ng memorya, ibinabalik ang NULL, kaya dapat laging magsagawa ng NULL check at magpatupad ng angkop na paghawak ng error.
  2. Alin ang dapat gamitin, malloc o calloc? Kung hindi kailangan ng initialization, gamitin ang malloc; kung nais mong i-zero-initialize ang memorya, gamitin ang calloc.
年収訴求