ਕੀ C ਵਿੱਚ malloc ਦੇ ਨਤੀਜੇ ਨੂੰ ਕਾਸਟ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ?

ਸੀ ਵਿੱਚ ਮੈਲੋਕ ਅਤੇ ਕਾਸਟਿੰਗ ਨੂੰ ਸਮਝਣਾ

C ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ, ਡਾਇਨਾਮਿਕ ਮੈਮੋਰੀ ਵੰਡ ਨੂੰ ਅਕਸਰ 'malloc' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਬੰਧਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਡਿਵੈਲਪਰਾਂ ਵਿੱਚ ਇੱਕ ਆਮ ਬਹਿਸ ਇਹ ਹੈ ਕਿ ਕੀ 'ਮੈਲੋਕ' ਦੇ ਨਤੀਜੇ ਨੂੰ ਪੁਆਇੰਟਰ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਵੇਲੇ ਕਾਸਟ ਕਰਨਾ ਹੈ ਜਾਂ ਨਹੀਂ। ਉਦਾਹਰਨ ਲਈ, ਕੀ `int *sieve = (*sieve) * length);` ਦੀ ਬਜਾਏ `int *sieve = malloc(sizeof(*sieve) * length);` ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਬਿਹਤਰ ਹੈ?

ਇਹ ਲੇਖ 'ਮੈਲੋਕ' ਨਤੀਜਿਆਂ ਦੀ ਕਾਸਟ ਤੋਂ ਬਚਣ ਦੇ ਪਿੱਛੇ ਤਰਕ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ। ਅਸੀਂ ਦੋਵਾਂ ਪਹੁੰਚਾਂ ਦੇ ਪ੍ਰਭਾਵਾਂ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ ਅਤੇ ਸਪੱਸ਼ਟਤਾ ਪ੍ਰਦਾਨ ਕਰਾਂਗੇ ਕਿ ਇੱਕ ਨੂੰ ਦੂਜੇ ਨਾਲੋਂ ਕਿਉਂ ਤਰਜੀਹ ਦਿੱਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਇਹਨਾਂ ਸੂਖਮਤਾਵਾਂ ਨੂੰ ਸਮਝਣਾ ਤੁਹਾਡੇ C ਪ੍ਰੋਗਰਾਮਿੰਗ ਅਭਿਆਸਾਂ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ।

ਸੀ ਵਿੱਚ ਮੈਲੋਕ ਅਤੇ ਮੈਮੋਰੀ ਮੈਨੇਜਮੈਂਟ ਵਿੱਚ ਡੂੰਘੀ ਡੁਬਕੀ

ਪਹਿਲੀ ਸਕਰਿਪਟ ਵਿੱਚ, ਅਸੀਂ ਦੀ ਵਰਤੋਂ ਦੇਖਦੇ ਹਾਂ 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 ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ।