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

மல்லாக்கின் முடிவை C இல் அனுப்புவது அவசியமா?
மல்லாக்கின் முடிவை 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 ஒரு முழு எண் வரிசைக்கு நினைவகத்தை மாறும் வகையில் ஒதுக்க. அறிக்கை 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 நினைவக கசிவை தவிர்க்க.

C இல் malloc இன் சரியான பயன்பாட்டைப் புரிந்துகொள்வது

சி நிரலாக்கம்

#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;
}

C இல் அனுப்பாமல் நினைவக ஒதுக்கீட்டை ஆராய்தல்

சி நிரலாக்கம்

#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 தோல்வி அடைகிறது.

C இல் malloc பற்றிய பொதுவான கேள்விகள் மற்றும் பதில்கள்

  1. என்ன செய்கிறது malloc நிற்க?
  2. malloc "நினைவக ஒதுக்கீடு" என்பதைக் குறிக்கிறது.
  3. முடிவை ஏன் பார்க்க வேண்டும் malloc?
  4. முடிவை நாங்கள் சரிபார்க்கிறோம் malloc நினைவக ஒதுக்கீடு வெற்றிகரமாக இருப்பதை உறுதிசெய்யவும் மற்றும் பூஜ்ய சுட்டியை மறுபரிசீலனை செய்வதைத் தவிர்க்கவும்.
  5. என்றால் என்ன நடக்கும் malloc தோல்வியா?
  6. என்றால் malloc தோல்வியுற்றால், அது ஒரு பூஜ்ய சுட்டியை வழங்குகிறது, இது வரையறுக்கப்படாத நடத்தையைத் தடுக்க சரிபார்க்கப்பட வேண்டும்.
  7. முடியும் malloc போதுமான நினைவகம் இருந்தாலும் பூஜ்ய சுட்டியை திருப்பி அனுப்பவா?
  8. ஆம், துண்டாடுதல் போன்ற பிற காரணிகள் ஏற்படலாம் malloc செயலிழக்க.
  9. என்ன வித்தியாசம் malloc மற்றும் calloc?
  10. malloc துவக்கப்படாத நினைவகத்தை ஒதுக்குகிறது calloc நினைவகத்தை பூஜ்ஜியத்திற்கு ஒதுக்குகிறது மற்றும் துவக்குகிறது.
  11. எப்படி செய்கிறது realloc வேலை?
  12. realloc ஏற்கனவே உள்ள நினைவக தொகுதியின் அளவை மாற்றுகிறது, உள்ளடக்கங்களை புதிய அளவு அல்லது அசல் அளவு, எது சிறியது வரை பாதுகாக்கிறது.
  13. மூலம் ஒதுக்கப்பட்ட நினைவகத்தை இலவசமாக்குவது அவசியமா? malloc?
  14. ஆம், இலவச நினைவகத்தில் தோல்வியுற்றது நினைவக கசிவுகளுக்கு வழிவகுக்கிறது, இது காலப்போக்கில் கணினி நினைவகத்தை வெளியேற்றும்.

மல்லோக் காஸ்டிங்கின் முக்கிய அம்சங்கள்:

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