மல்லாக்கின் முடிவை C இல் அனுப்புவது அவசியமா?

சியில் மல்லோக் மற்றும் காஸ்டிங் ஆகியவற்றைப் புரிந்துகொள்வது

சி நிரலாக்கத்தில், டைனமிக் நினைவக ஒதுக்கீடு பெரும்பாலும் `மல்லோக்` செயல்பாட்டைப் பயன்படுத்தி நிர்வகிக்கப்படுகிறது. டெவலப்பர்களிடையே ஒரு பொதுவான விவாதம், ஒரு சுட்டிக்காட்டிக்கு அதை ஒதுக்கும்போது `malloc` இன் முடிவை அனுப்ப வேண்டுமா என்பதுதான். எடுத்துக்காட்டாக, `int *sieve = (int *)malloc(sizeof(*sieve) * length);` என்பதற்குப் பதிலாக `int *sieve = malloc(sizeof(*sieve) * length);` பயன்படுத்துவது சிறந்ததா?

இந்தக் கட்டுரை `மல்லோக்' முடிவுகளின் நடிகர்களைத் தவிர்ப்பதற்குப் பின்னால் உள்ள காரணத்தை ஆராய்கிறது. இரண்டு அணுகுமுறைகளின் தாக்கங்களையும் நாங்கள் ஆராய்வோம் மற்றும் ஒன்று ஏன் மற்றொன்றை விட விரும்பப்படலாம் என்பதற்கான தெளிவை வழங்குவோம். இந்த நுணுக்கங்களைப் புரிந்துகொள்வது உங்கள் சி நிரலாக்க நடைமுறைகளை மேம்படுத்த உதவும்.

சியில் மல்லோக் மற்றும் மெமரி மேனேஜ்மென்ட்டில் ஆழ்ந்து மூழ்குங்கள்

முதல் ஸ்கிரிப்ட்டில், பயன்படுத்துவதைக் காண்கிறோம் 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 தோல்வி அடைகிறது.