malloc ൻ്റെ ഫലം C-യിൽ കാസ്റ്റിംഗ് ആവശ്യമാണോ?

സിയിൽ malloc, കാസ്റ്റിംഗ് എന്നിവ മനസ്സിലാക്കുന്നു

സി പ്രോഗ്രാമിംഗിൽ, ഡൈനാമിക് മെമ്മറി അലോക്കേഷൻ പലപ്പോഴും 'malloc' ഫംഗ്ഷൻ ഉപയോഗിച്ചാണ് കൈകാര്യം ചെയ്യുന്നത്. ഒരു പോയിൻ്ററിലേക്ക് അസൈൻ ചെയ്യുമ്പോൾ `malloc` ഫലം കാസ്‌റ്റ് ചെയ്യണോ എന്നതാണ് ഡെവലപ്പർമാർക്കിടയിൽ ഒരു പൊതു ചർച്ച. ഉദാഹരണത്തിന്, `int *sieve = (int *)malloc(sizeof(*sieve) * length);` എന്നതിനുപകരം `int *sieve = malloc(sizeof(*sieve) * length);` ഉപയോഗിക്കുന്നതാണോ നല്ലത്?

ഈ ലേഖനം `malloc' ഫലങ്ങളുടെ കാസ്റ്റ് ഒഴിവാക്കുന്നതിന് പിന്നിലെ ന്യായവാദം പരിശോധിക്കുന്നു. രണ്ട് സമീപനങ്ങളുടെയും പ്രത്യാഘാതങ്ങൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യുകയും ഒന്ന് മറ്റൊന്നിനേക്കാൾ മുൻഗണന നൽകുകയും ചെയ്യുന്നത് എന്തുകൊണ്ടാണെന്ന് വ്യക്തമാക്കുകയും ചെയ്യും. ഈ സൂക്ഷ്മതകൾ മനസ്സിലാക്കുന്നത് നിങ്ങളുടെ സി പ്രോഗ്രാമിംഗ് രീതികൾ മെച്ചപ്പെടുത്താൻ സഹായിക്കും.

സിയിലെ 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;
}

സിയിലെ മെമ്മറി അലോക്കേഷൻ്റെ സൂക്ഷ്മതകൾ

സിയിലെ മെമ്മറി അലോക്കേഷൻ്റെ മറ്റൊരു നിർണായക വശം തമ്മിലുള്ള വ്യത്യാസങ്ങൾ മനസ്സിലാക്കുക എന്നതാണ് 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 പരാജയപ്പെടുന്നു.