malloc() vs calloc() – Difference Between malloc() and calloc() in C

Here in this tutorial you will learn about difference between malloc() and calloc() in C.

We all know that memory is available in limited size only, so it becomes important for us to use it efficiently. If we are writing a program that uses too much of memory resulting in wastage of memory or conversely if we allocate too little memory so that we can’t store enough information, that means we are not sure of the amount of data to be stored. In such cases, dynamic memory allocation comes to the rescue, where our program is capable to allocate whatever amount of memory it needs during the run-time of programs.

Now the question arises is that how can we achieve dynamic memory allocation in our programs?

In the C Language, we have predefined functions like calloc() and malloc() defined under the stdlib.h header file that can be used to allocate memory during the runtime of a program.

Let’s understand this awesomely useful function with simple examples:

malloc() Function

malloc() is an abbreviation for memory-allocation. It is a predefined function defined in the stdlib.h header file. It is used to allocate memory during the runtime of a program. The memory allocated is uninitialized that means it has garbage values.

Syntax:

ptr = (type*) malloc (size in bytes to be allocated)

The malloc() function takes size in bytes to be allocated as argument. If the memory allocation is successful, it returns a void pointer to the beginning of the allocated memory. This void pointer can be type-casted to any type of pointer. If the memory allocation fails due to reasons like insufficient memory, the malloc() function returns a NULL pointer.

It is the responsibility of the programmer to deallocate the allocated memory before program ends using free() or realloc() functions.

C Program Implementation of malloc() Function

#include <stdio.h>  
#include <stdlib.h>

int main()  
{
    /* The memory allocated by malloc contains garbage value */   
    /* allocates 10*sizeof(int) = 40 bytes of memory */  
    int *ptr1 = (int*)malloc( 10 * sizeof(int));      
    
    /* allocates 8*sizeof(char) = 8 bytes of memory  */  
    char *ptr2 = (char*)malloc( 8 * sizeof(char)); 
    
    if(ptr1)   
    { 
        printf("Memory allocation successful !!");  
        
    }  
    else  
    {  
        printf("Memory allocation failed !!");  
        
    }  
    
    free(ptr1);  
    free(ptr2);  
    return 0;  
}

Output

Memory allocation successful !!

calloc() Function

calloc() is an abbreviation for c-contiguous a-allocation. It is an advancement over the malloc() function. It is used to allocate multiple blocks of memory of the same size dynamically. The memory is initialized with zero.

Syntax:

ptr = (type*) calloc (number of blocks , the size of blocks in bytes to be allocated)

The calloc() function takes two arguments. First argument is the number of blocks of memory to be allocated and the second argument is used to define the size of blocks in terms of bytes. If the memory allocation is successful, it returns a void pointer to the beginning of the allocated memory. This void pointer can be type-casted to any type of pointer. If the memory allocation fails due to reasons like insufficient memory, the calloc() function returns a NULL pointer.

It is the responsibility of the programmer to deallocate the allocated memory before program ends using free() or realloc() functions.

C Program Implementation of calloc() Function

#include <stdio.h>  
#include <stdlib.h>  

int main()  
{  
    /* The calloc function initialize the memory with 0 */   
    /* allocates 4 blocks of memory with size of int */  
    int *ptr1 = (int*)calloc(4, sizeof(int));      
    
    /* allocates 8 blocks of memory with size of float */  
    float *ptr2 = (float*)calloc(8, sizeof(float));   
    
    if(ptr1)   
    {  
        printf("The values are:\n");  
        for(int i=0;i<4;i++)  
        {  
            /* printing the data of memory-allocated */  
            printf("Memory block %d : %d \n",i+1,*(ptr1+i));   
        }  
    }  
    else  
    {  
        printf("Memory allocation failed !!");  
    } 
    
    free(ptr1);  
    free(ptr2);  
    
    return 0;  
}

Output

The values are:
Memory block 1 : 0
Memory block 2 : 0
Memory block 3 : 0
Memory block 4 : 0

malloc() vs calloc() – Difference between malloc() and calloc()

Comment down below if you have any queries related to malloc() and calloc() in C.