பாடம் 1 / 2 · Dynamic Memory · படிக்க 3 min · புதுப்பிக்கப்பட்டது

malloc-ம் free-ம்

தேவைப்படும்போது memory-யை கேட்டு வாங்கிக்கோங்க. வேலை முடிஞ்சதும் அதை திருப்பிக் கொடுத்துடுங்க.

இதுவரைக்கும் நாம பயன்படுத்தின ஒவ்வொரு array-வோட size-ம், code எழுதும்போதே fix ஆயிடும் — int marks[5] எப்பவும் 5 numbers-ஐ மட்டும்தான் வச்சுக்க முடியும். ஆனா program ஓடும்போதுதான் எத்தனை values தேவைன்னு தெரியுதுன்னா? உதாரணத்துக்கு, user எத்தனை students இருக்காங்கன்னு சொல்லுறாரு, இல்லனா ஒரு file-ல 400 lines இருக்கு. இப்படி run ஆகும்போதுதான் size தெரியுற இடத்துல தான் dynamic memory பயன்படும்.

c
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int n;

    printf("How many numbers? ");
    scanf("%d", &n);

    int *marks = malloc(n * sizeof(int));

    if (marks == NULL) {
        printf("Out of memory\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        marks[i] = i * 10;
    }

    printf("Last: %d\n", marks[n - 1]);

    free(marks);
    return 0;
}

ஒவ்வொரு பகுதியும் என்ன செய்யுது

  1. #include <stdlib.h>

    malloc-ம் free-ம் stdlib.h-ல தான் இருக்கு, stdio.h-ல கிடையாது. இந்த include-ஐ மறந்துடுறதுதான் நிறைய பேர் பண்ற முதல் தப்பு.

  2. n * sizeof(int)

    malloc memory-யை bytes-ல தான் கணக்கு போடும்; elements-ல இல்ல. sizeof(int) இந்த machine-ல ஒரு int எவ்வளவு memory எடுத்துக்கும்னு compiler-கிட்ட கேக்குது — அதனால எந்த machine-லயும் சரியான அளவு allocate ஆகும்.

  3. if (marks == NULL)

    Memory கிடைக்கலன்னா malloc NULL-ஐ return பண்ணும். Check பண்ணாம pointer-ஐ use பண்ணா crash ஆகலாம். இன்னும் tricky: சின்ன allocation-கள்ல வருஷக்கணக்கா சரியா ஓடி, ஒரு நாள் பெரிய memory தேவைப்படும்போது தான் திடீர்னு crash ஆகலாம்.

  4. marks[i] = i * 10;

    Pointer கிடைச்சதும், அதை array மாதிரியே use பண்ணலாம். Pointers topic-ல பார்த்த மாதிரி, pointer-கூட [] use பண்ண முடியும்.

  5. free(marks);

    வாங்கின memory-யை வேலை முடிஞ்சதும் system-க்கு திருப்பிக் கொடுக்குது. Free பண்ணாத வரைக்கும், use பண்ணாம இருந்தாலும் program அதை பிடிச்சு வெச்சுக்கிட்டே இருக்கும்.

Stack-ம் heap-ம்

சாதாரண local variable-கள் stack-ல இருக்கும் — function ஆரம்பிக்கும்போது உருவாகி, முடிஞ்சதும் தானாவே போயிடும். ஆனா malloc மூலமா வாங்குற memory heap-ல இருக்கும் — நாம free பண்ணுற வரைக்கும், நடுவுல எத்தனை functions வந்து போனாலும் அப்படியே இருக்கும். ஒரு function data-வை உருவாக்கி, call பண்ணினவங்களுக்கு திருப்பிக் கொடுக்கணும்னா, dynamic memory இதுக்கு உதவும்.

Warning

Local variable-ஓட pointer-ஐ ஒருபோதும் return பண்ணாதீங்க. Function முடிஞ்சதும் அந்த variable-ம் போயிடும்; pointer பயன்படுத்தக்கூடாத memory-யை point பண்ணும். இன்னொரு பிரச்சினை — program உடனே crash ஆகாம, எல்லாம் சரியா வேலை செய்ற மாதிரி கூட தெரியலாம். அதனாலதான் இந்த bug ரொம்ப மோசமானது.

malloc(n * sizeof(int))-ல sizeof(int) ஏன் use பண்றோம்?

Create a free account to save your progress, or sign in.