ಸಿ ಯಲ್ಲಿ 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 ವಿಫಲವಾಗುತ್ತದೆ.