ಸಿ ಯಲ್ಲಿ 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++ ಕಂಪೈಲರ್‌ಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತೇವೆ. ಫಲಿತಾಂಶವನ್ನು ಯಾವಾಗಲೂ ಪರಿಶೀಲಿಸಿ ಯಶಸ್ವಿ ಮೆಮೊರಿ ಹಂಚಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಮತ್ತು ಸೋರಿಕೆಯನ್ನು ತಪ್ಪಿಸಲು ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸಲು ಮರೆಯದಿರಿ. ಈ ಅಭ್ಯಾಸಗಳು ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಸಿ ಕೋಡ್‌ಗೆ ಕೊಡುಗೆ ನೀಡುತ್ತವೆ, ಒಟ್ಟಾರೆ ಪ್ರೋಗ್ರಾಂ ಸ್ಥಿರತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತವೆ.