Difference Between The Malloc Calloc Realloc Functions In C

It involves the act of allocating memory to data structures at runtime rather than during the compilation stage. This method provides adaptability and effectiveness. Functions such as malloc, calloc, and realloc are utilized for this task. Dynamic allocation enables the allocation of memory as needed, reducing inefficiencies and optimizing resource utilization. This is crucial when managing intricate data structures like arrays and linked lists. It becomes especially valuable when processing data of varying sizes, enhancing program flexibility and its ability to manage diverse operations.

Functions used in dynamic memory allocations are:

Memory allocation using malloc involves reserving a specific amount of memory and providing a pointer to the allocated memory block. Unlike initialization, malloc simply sets aside memory without altering its contents, which is advantageous for diverse data structures.

Calloc: This function reserves and initializes memory to zero. It is particularly useful for arrays and intricate data structures, guaranteeing that every element begins with specific values.

Realloc: It dynamically adjusts the size of allocated memory, maintaining the current data when expanding or reducing arrays. This feature lessens the requirement for manual memory handling, enhancing the efficiency and clarity of code. Realloc becomes essential when the dimensions of a data structure alter while the program is running.

Example:

Now, let's examine how the malloc and calloc functions operate:

#include <stdio.h>

#include <stdlib.h>

int main() {

    int *dynamicArrayMalloc = NULL;

    int *dynamicArrayCalloc = NULL;

    int size = 5;

    dynamicArrayMalloc = (int *)malloc(size * sizeof(int));

    if (dynamicArrayMalloc == NULL) {

        printf("Memory allocation failed (malloc).\n");

        return 1;

    }

    for (int i = 0; i < size; i++) {

        dynamicArrayMalloc[i] = i * 2;

    }

    dynamicArrayCalloc = (int *)calloc(size, sizeof(int));

    if (dynamicArrayCalloc == NULL) {

        printf("Memory allocation failed (calloc).\n");

        return 1;

    }

    for (int i = 0; i < size; i++) {

        dynamicArrayCalloc[i] = i * 2 + 1;

    }

    printf("Array allocated with malloc: ");

    for (int i = 0; i < size; i++) {

        printf("%d ", dynamicArrayMalloc[i]);

    }

    printf("\n");

    printf("Array allocated with calloc: ");

    for (int i = 0; i < size; i++) {

        printf("%d ", dynamicArrayCalloc[i]);

    }

    printf("\n");

    free(dynamicArrayMalloc);

    free(dynamicArrayCalloc);

    return 0;

}

Output:

Memory allocation failed (malloc).
Memory allocation failed (calloc).
Array allocated with malloc: [value] Array allocated with calloc: [value]

Explanation:

In this instance, we declare and set up two integer arrays, named dynamicArrayMalloc and dynamicArrayCalloc, each with a capacity of 5 elements. Initially, memory allocation is performed for dynamicArrayMalloc using malloc, where the elements are initialized with even numbers. Subsequently, memory allocation for dynamicArrayCalloc is carried out using calloc, setting all elements to zero. The script then modifies dynamicArrayCalloc by updating its elements with odd numbers. Lastly, the script displays the contents of both arrays and releases the allocated memory to avoid memory leaks.

Example:

Next, let's explore another example to understand how the realloc function operates:

#include <stdio.h>

#include <stdlib.h>



int main() {

    int* dynamicArray = NULL; 

    int initialSize = 5;      

    int newSize = 10;         

    dynamicArray = (int*)malloc(initialSize * sizeof(int));

    if (dynamicArray == NULL) {

        printf("Memory allocation failed.\n");

        return 1; 

    }

    for (int i = 0; i < initialSize; i++) {

        dynamicArray[i] = i * 2;

    }

    printf("Initial Array: ");

    for (int i = 0; i < initialSize; i++) {

        printf("%d ", dynamicArray[i]);

    }

    printf("\n");

    dynamicArray = (int*)realloc(dynamicArray, newSize * sizeof(int));

    if (dynamicArray == NULL) {

        printf("Memory reallocation failed.\n");

        return 1;  

    }

    for (int i = initialSize; i < newSize; i++) {

        dynamicArray[i] = i * 3;

    }

    printf("Resized Array: ");

    for (int i = 0; i < newSize; i++) {

        printf("%d ", dynamicArray[i]);

    }

    printf("\n");

    free(dynamicArray);

    return 0; 

}

Output:

Memory allocation failed (malloc).
Memory allocation failed (calloc).
Array allocated with malloc: [value] Array allocated with calloc: [value]

Explanation:

In this instance, we reserve memory for a integer array named dynamicArray, starting with a size of 5. Following the initialization with even integers, the code reallocates the memory to support 10 elements using the realloc function. It maintains the current data during the resizing process. Next, it fills the new elements with values determined by their positions. The script displays both the original and adjusted arrays, highlighting the versatility of dynamic memory allocation.

Head-to-head comparison between Malloc, Calloc, and Realloc:

Now, the distinction among all the functions is: