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

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

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

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

கட்டளை	விளக்கம்
malloc	நினைவகத்தின் குறிப்பிட்ட எண்ணிக்கையிலான பைட்டுகளை ஒதுக்குகிறது மற்றும் ஒதுக்கப்பட்ட நினைவகத்திற்கு ஒரு சுட்டியை வழங்குகிறது.
sizeof	மாறி அல்லது தரவு வகையின் பைட்டுகளில் அளவை தீர்மானிக்கிறது.
fprintf	stderr போன்ற குறிப்பிட்ட ஸ்ட்ரீமில் வடிவமைக்கப்பட்ட சரத்தை அச்சிடுகிறது.
perror	கடைசியாக ஏற்பட்ட பிழையின் அடிப்படையில் விளக்கமான பிழை செய்தியை stderrக்கு அச்சிடுகிறது.
EXIT_FAILURE	தோல்வியுற்ற நிரல் முடிவைக் குறிக்கும் மேக்ரோ.
free	முன்பு ஒதுக்கப்பட்ட நினைவகத்தை ஒதுக்குகிறது.

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

முதல் ஸ்கிரிப்ட்டில், பயன்படுத்துவதைக் காண்கிறோம் ஒரு முழு எண் வரிசைக்கு நினைவகத்தை மாறும் வகையில் ஒதுக்க. அறிக்கை முழு எண்களின் 'நீளம்' எண்ணிக்கைக்கான நினைவகத்தைக் கோருகிறது. பயன்படுத்தி , சுட்டிக்காட்டி வகையைப் பொருட்படுத்தாமல் சரியான அளவு நினைவகம் ஒதுக்கப்படுவதை உறுதிசெய்கிறோம். இந்த முறையின் முடிவை வார்ப்பதற்கான தேவையைத் தவிர்க்கிறது malloc. நினைவக ஒதுக்கீடு தோல்வியுற்றால், நிரல் பயன்படுத்துகிறது நிலையான பிழை ஸ்ட்ரீமில் ஒரு பிழை செய்தியை அச்சிட்டு, பின்னர் பூஜ்ஜியமற்ற நிலையுடன் வெளியேறும். ஒதுக்கப்பட்ட நினைவகம் 1 முதல் 'நீளம்' வரை முழு எண்களைச் சேமிக்கப் பயன்படுகிறது, பின்னர் அதைப் பயன்படுத்தி விடுவிக்கப்படுவதற்கு முன்பு அச்சிடப்படுகிறது. .

இரண்டாவது ஸ்கிரிப்ட்டில், இதே போன்ற கட்டமைப்பைப் பின்பற்றுகிறோம், ஆனால் அதற்குப் பதிலாக இரட்டையர்களின் வரிசைக்கு நினைவகத்தை ஒதுக்குகிறோம். வரி இரட்டைகளின் 'நீளம்' எண்ணுக்கு நினைவகத்தை ஒதுக்குகிறது. ஒதுக்கீடு தோல்வியுற்றால், தி செயல்பாடு ஒரு விளக்கமான பிழை செய்தியை அச்சிடுகிறது மற்றும் நிரல் வெளியேறுகிறது . ஒதுக்கப்பட்ட நினைவகம் இரட்டை மதிப்புகளைச் சேமிக்கப் பயன்படுகிறது, அவை இரட்டை எண்களுக்குத் துவக்கப்படுகின்றன. இந்த மதிப்புகள் அச்சிடப்பட்டு, இறுதியாக, நினைவகம் பயன்படுத்தி விடுவிக்கப்படுகிறது free(array);. இரண்டு ஸ்கிரிப்ட்களும் வெற்றியை சரிபார்க்க வேண்டியதன் முக்கியத்துவத்தை நிரூபிக்கின்றன மற்றும் சரியான பயன்பாடு நினைவக கசிவை தவிர்க்க.

#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 நினைவகத்தின் தொகுதியை துவக்காமல் ஒதுக்குகிறது, இரண்டும் நினைவக தொகுதியை பூஜ்ஜியத்திற்கு ஒதுக்கி துவக்குகிறது. இது துவக்கப்படாத நினைவகத்தைப் பயன்படுத்துவதால் ஏற்படும் சில வகையான பிழைகளைத் தடுக்கலாம். உதாரணமாக, அனைத்து உறுப்புகளும் பூஜ்ஜியமாகத் தொடங்கப்படுவதை உறுதிசெய்கிறது, இது உங்களுக்கு சுத்தமான ஸ்லேட் தேவைப்படும்போது பயனுள்ளதாக இருக்கும்.

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

முடிவில், இதன் விளைவாக நடிப்பது C இல் தேவையில்லை மற்றும் குறைவான படிக்கக்கூடிய குறியீடு மற்றும் சாத்தியமான பிழைகள் ஏற்படலாம். நடிகர்களைத் தவிர்ப்பதன் மூலம், நாங்கள் C தரநிலைகளைக் கடைப்பிடிக்கிறோம் மற்றும் C++ கம்பைலர்களுடன் இணக்கத்தன்மையைப் பராமரிக்கிறோம். முடிவை எப்போதும் சரிபார்க்கவும் வெற்றிகரமான நினைவக ஒதுக்கீட்டை உறுதிப்படுத்தவும், கசிவுகளைத் தவிர்க்க ஒதுக்கப்பட்ட நினைவகத்தை விடுவிக்கவும். இந்த நடைமுறைகள் மிகவும் உறுதியான மற்றும் பராமரிக்கக்கூடிய C குறியீட்டிற்கு பங்களிக்கின்றன, ஒட்டுமொத்த நிரல் நிலைத்தன்மையை மேம்படுத்துகிறது.