શું C માં malloc ના પરિણામને કાસ્ટ કરવું જરૂરી છે?

C માં malloc અને Casting ને સમજવું

C પ્રોગ્રામિંગમાં, ડાયનેમિક મેમરી ફાળવણી ઘણીવાર `malloc` ફંક્શનનો ઉપયોગ કરીને મેનેજ કરવામાં આવે છે. વિકાસકર્તાઓ વચ્ચે એક સામાન્ય ચર્ચા એ છે કે શું `malloc` નું પરિણામ જ્યારે તેને નિર્દેશકને સોંપવામાં આવે ત્યારે તેને કાસ્ટ કરવું. ઉદાહરણ તરીકે, શું `int *sieve = (int*)malloc(sizeof(*seveof) * length);` ને બદલે `int *sieve = malloc(sizeof(*seve) * length);` નો ઉપયોગ કરવો વધુ સારું છે?

આ લેખ `malloc` પરિણામોના કાસ્ટને ટાળવા પાછળના તર્કની શોધ કરે છે. અમે બંને અભિગમોની અસરોનું અન્વેષણ કરીશું અને શા માટે એકને બીજા કરતાં પ્રાધાન્ય આપી શકાય તે અંગે સ્પષ્ટતા પ્રદાન કરીશું. આ ઘોંઘાટને સમજવાથી તમારી C પ્રોગ્રામિંગ પ્રેક્ટિસને સુધારવામાં મદદ મળી શકે છે.

C માં malloc અને મેમરી મેનેજમેન્ટમાં ડીપ ડાઇવ કરો

પ્રથમ સ્ક્રિપ્ટમાં, આપણે નો ઉપયોગ જોઈએ છીએ malloc પૂર્ણાંક એરે માટે ગતિશીલ રીતે મેમરી ફાળવવા માટે. નિવેદન int *sieve = malloc(sizeof(*sieve) * length); પૂર્ણાંકોની 'લંબાઈ' સંખ્યા માટે મેમરીની વિનંતી કરે છે. ઉપયોગ કરીને sizeof(*sieve), અમે સુનિશ્ચિત કરીએ છીએ કે પોઇન્ટર પ્રકારને ધ્યાનમાં લીધા વિના મેમરીની યોગ્ય રકમ ફાળવવામાં આવી છે. આ પદ્ધતિ પરિણામને કાસ્ટ કરવાની જરૂરિયાતને ટાળે છે malloc. જો મેમરી ફાળવણી નિષ્ફળ જાય, તો પ્રોગ્રામ ઉપયોગ કરે છે fprintf(stderr, "Memory allocation failed\n"); સ્ટાન્ડર્ડ એરર સ્ટ્રીમમાં ભૂલ સંદેશ છાપવા માટે અને પછી બિન-શૂન્ય સ્થિતિ સાથે બહાર નીકળો. ફાળવેલ મેમરીનો ઉપયોગ 1 થી 'લંબાઈ' સુધીના પૂર્ણાંકોને સંગ્રહિત કરવા માટે થાય છે અને બાદમાં તેનો ઉપયોગ કરીને મુક્ત કરવામાં આવે તે પહેલાં તેને છાપવામાં આવે છે. free(sieve);.

બીજી સ્ક્રિપ્ટમાં, અમે સમાન બંધારણને અનુસરીએ છીએ પરંતુ તેના બદલે ડબલ્સની એરે માટે મેમરી ફાળવીએ છીએ. રેખા double *array = malloc(sizeof(*array) * length); ડબલ્સની 'લંબાઈ' સંખ્યા માટે મેમરી ફાળવે છે. જો ફાળવણી નિષ્ફળ જાય, તો perror ફંક્શન વર્ણનાત્મક ભૂલ સંદેશ છાપે છે અને પ્રોગ્રામ તેની સાથે બહાર નીકળી જાય છે EXIT_FAILURE. ફાળવેલ મેમરીનો ઉપયોગ બેવડા મૂલ્યોને સંગ્રહિત કરવા માટે થાય છે, જે બેવડી સંખ્યામાં પ્રારંભ થાય છે. આ મૂલ્યો છાપવામાં આવે છે, અને છેલ્લે, મેમરીનો ઉપયોગ કરીને મુક્ત થાય છે free(array);. બંને સ્ક્રિપ્ટ ની સફળતાને તપાસવાનું મહત્વ દર્શાવે છે malloc અને તેનો યોગ્ય ઉપયોગ free મેમરી લિક ટાળવા માટે.

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

int main() {
    int length = 10;
    int *sieve = malloc(sizeof(*sieve) * length);
    if (sieve == ) {
        fprintf(stderr, "Memory allocation failed\\n");
        return 1;
    }

    for (int i = 0; i < length; i++) {
        sieve[i] = i + 1;
    }

    for (int i = 0; i < length; i++) {
        printf("%d ", sieve[i]);
    }
    printf("\\n");

    free(sieve);
    return 0;
}

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

int main() {
    int length = 5;
    double *array = malloc(sizeof(*array) * length);
    if (array == ) {
        perror("Failed to allocate memory");
        return EXIT_FAILURE;
    }

    for (int i = 0; i < length; i++) {
        array[i] = i * 2.0;
    }

    for (int i = 0; i < length; i++) {
        printf("%f\\n", array[i]);
    }

    free(array);
    return 0;
}

C માં મેમરી ફાળવણીની ઘોંઘાટ

C માં મેમરી ફાળવણીનું બીજું મહત્ત્વનું પાસું વચ્ચેના તફાવતોને સમજવું છે malloc અને અન્ય મેમરી ફાળવણી કાર્યો જેમ કે calloc અને realloc. જ્યારે malloc મેમરીના બ્લોકને પ્રારંભ કર્યા વિના ફાળવે છે, calloc બંને મેમરી બ્લોકને શૂન્ય પર ફાળવે છે અને પ્રારંભ કરે છે. આ અમુક પ્રકારની ભૂલોને અટકાવી શકે છે જે અપ્રારંભિત મેમરીનો ઉપયોગ કરવાથી ઉદ્ભવે છે. દાખલા તરીકે, int *arr = calloc(length, sizeof(*arr)); ખાતરી કરે છે કે તમામ ઘટકો શૂન્ય-પ્રારંભિક છે, જે તમને જ્યારે સ્વચ્છ સ્લેટની જરૂર હોય ત્યારે ઉપયોગી છે.

બીજી બાજુ, realloc વર્તમાન મેમરી બ્લોકનું કદ બદલવા માટે વપરાય છે. જો તમારે ફાળવેલ મેમરી બ્લોકનું કદ બદલવાની જરૂર હોય, realloc નવો બ્લોક ફાળવવા અને સમાવિષ્ટોની નકલ કરવા કરતાં વધુ કાર્યક્ષમ વિકલ્પ હોઈ શકે છે. દાખ્લા તરીકે, arr = realloc(arr, new_length * sizeof(*arr)); દ્વારા નિર્દેશિત મેમરી બ્લોકના કદને સમાયોજિત કરે છે arr સમાવવા માટે new_length તત્વો જો કે, તે નિયંત્રિત કરવા માટે નિર્ણાયક છે realloc મેમરી લીક અથવા મૂળ મેમરી બ્લોક ગુમાવવાનું ટાળવા માટે કાળજીપૂર્વક realloc નિષ્ફળ