Online Tutorials & Training Materials |
Register Login

Differences Between Malloc and Calloc Functions in C Language

|| || 0

Differences Between Malloc and Calloc Functions in C Language

Know the differences and similarities that exist between calloc and malloc functions, understand the definition and syntax of calloc and malloc, etc.

The fundamental difference that exists between malloc and calloc in C language pertains to calloc() requiring two arguments in lieu of a single argument as needed by malloc(). Both calloc and malloc in C are essential functions of the middle-level programming language. They go a along way in enabling the cause of de-allocation and dynamic memory allocation at run time.

Calloc vs Malloc

Through this article, we aim to enlighten you about the definition of calloc and malloc, the syntax of calloc and malloc and the key difference between calloc and malloc. We will also discuss the similarities between these two functions and the features of C Dynamic Memory Allocation to enable the cause of your short and long-term C programming needs. Read on for more.

Calloc vs. Malloc

If you are still wondering about what is the difference between calloc and malloc, then this table will help you understand the distinctive properties with greater clarity.

Basis of Difference



No of blocks

Malloc() allocates a singular block of the memory required in bytes.

Calloc() allocates multiple blocks of the requested memory to any process or program dynamically.


void *malloc(size_t size);

void *calloc(size_t num, size_t size);


malloc()fails to initialize and clear out the allocated memory. It contains a random garbage value and the allocated memory item is incapable of being altered.

The calloc() initializes the earlier allocated memory to zero.


The malloc() performs quickly and without any lags.

The calloc () is comparatively slow and takes a longer time to complete as it first initializes the value of the pointer to ZERO. However, this lag is miniscule and does not affect the performance of the program in any manner.

Type of memory allocation

The malloc() function assigns memory of the desired 'size' from the available heap.

The calloc() function assigns memory that is the size of what’s equal to ‘num *size’.

Meaning on name

The name malloc is attributed to memory allocation.

The name calloc means contiguous allocation.

Returning of pointer

void *malloc(size_t n) will return a pointer to get a value of n bytes of uninitialized storage if the request is satisfied. Conversely, it will give it a  NULL value if the request fails to be successful. In case the memory space allocated by malloc() gets overrun, then the results will remain as undefined.

void *calloc(size_t n, size_t size) will return a pointer to allocate enough free space pertaining to an array of n objects; which will be of a pre-defined and specified size. The NULL value is assigned in case the request fails to be satisfied. Here, the storage is again initialized to zero.

Types of arguments taken

Malloc() takes in just one argument – the number of bytes.


Calloc() takes in two arguments – the number of blocks as well as the size of every single block.

Definition of Malloc()

The malloc function in C programming language is used for assigning a block of memory as bytes. The programmer is required to give the block size required for use in an explicit manner. The malloc function program refers to the RAM for the user system to enable the cause of memory allocation. In case the malloc function concedes, or in other words, is successful in allocating the desire memory, then a pointer is returned to the block of memory created right in the beginning.

The pointer so returned by the Malloc() function is of the void type. It means that a pointer of any type can be assigned for taking care of the coding needs of the C programmer. A NULL value is returned in case the malloc() function is unable to unable to assign the amount of memory needed. The malloc function can be accessed in TURBO C via its header file stdlib.h or alloc.h. If you are a coder using the UNIX platform, then the header file <malloc.h> will be useful for your needs.

Syntax of Malloc()

The syntax of malloc function is:

malloc(number of elements * size of each element);

For instance:

ptr= malloc(10*sizeof (int)}

Here, size ideally represents the memory size that needs to be allocated in bytes. In other words, it refers to the number of memory locations (contiguous) that have to be allocated in bytes.

However, as mentioned earlier, as the malloc function is known to return a void pointer, the necessity of cast operator comes into play. A cast operator is needed for transforming the pointer type as returned, and on the basis of the coding needs. For instance, the declaration can also be presented as:

ptr_var=(type_cast*) malloc(size)

Here, ptr_var refers to the pointer’s name that still has the initial address of the memory block allocated earlier; type_cast refers to the data type that the type void return pointer will be transformed into. The (size) in the malloc syntax describes the allocated memory block size in bytes.

For instance,

ptr=(int*) malloc (10*size of (int));

Here, the memory allocated by the malloc() will contain garbage value.

This has to be noted to assess if the corresponding request that has been generated by malloc for the sake of memory allocation has been successfully granted by the system RAM or not. The memory allocation request will be rejected in case there is no space available – the malloc function will return a NULL in case memory has not been allocated.

Definition of calloc()

The calloc function requires two arguments instead of one as used by malloc(). Otherwise, it operates in exactly the same way as malloc(). When calloc is declared for the sake of allocating a block of memory, the assigned region is immediately initialized to zero. This is not the case with malloc that resists from touching the allocated memory block and its contents. This malloc and calloc difference aptly describes the main attribute of calloc function in C.

Syntax of Calloc()

The C library function

void *calloc(size_t nitems, size_t size)

is used for allocating the requested memory. It is also responsible for returning a pointer to the same. While malloc() does not set the allocated memory to zero, the calloc() does this to set the memory value to zero.

For instance:

ptr = (int*) calloc(10,2);

Here, the figure 2 specifies the data type size in bytes for which the memory allocation has to be made. In this case, 2 stands for integers. The figure 10 signifies the total number of elements that require memory allocation.

The argument passed in case of the malloc function was (n*10); it was single argument which was depicted as a simple expression (this is because there were no commas separating any more arguments). This is not the case with the calloc function. This is a major difference between malloc and calloc in C.

In the calloc() declaration, when the same is executed successfully, a memory block amounting to 20 bytes in size will be allocated to the program requesting the same.
The address given to the first memory block will be allocated to the requesting program. Additionally, the address pertaining to the first block will be allocated to the pointer referred to as ptr. The memory space allocated by the calloc function would hold all zeros. This function is available in the header file saved as <alloc.h> or <stdlib.h> in TURBO C.

Key Difference between Calloc and Malloc

There exist two differences in between calloc and malloc in terms of C programming languages. The first difference is visible in context to the number of arguments. While malloc() uses a single argument, The calloc() requires two arguments for the completion of its operations.

Secondly, the initialization of allocated memory does not take place in the malloc function. Conversely, the calloc() initializes the value of the allocated memory to zero. The table below chalks out the difference between malloc and calloc in C in details.

Similarities Between Malloc and Calloc

Both calloc and malloc are utilized for the purposes of dynamic memory allocation in C language. They are used for obtaining and allocating memory blocks in a dynamic fashion. The pointer returned by both malloc or calloc have proper alignment with regards to the object in the reckoning. However, they must first be cast into appropriate types for the process to be successful.

By proper alignment we mean that the value assigned to the returned address will be guaranteed to figure as an even multiple of alignment. Here, the value attributed to the alignment should be a power of two; also, it must either be equal to or greater than the size of a given words. Yet another similarity is that the calloc() and malloc() functions will fail to be successful in the following cases:

1. If the physical limits defined for the system is exceeded by n memory bytes that cannot be assigned.

2. If the adequate memory is not available for the allocation of n bytes of system memory; it becomes possible for the application to try again later.

C Dynamic Memory Allocation

Dynamic memory allocation is an important and unique feature attributed to C language. It enables programmers to create data structures and types of different sizes and lengths as is suited to the program in the reckoning. Memory allocation relates to the assigning of computer memory to enable the execution of processes and programs. Dynamic allocation techniques are generally used when the coders are not aware of the amount of memory space that will be required for the running of any program and/or process.

Dynamic memory allocation in C language is attributed to the issues linked with static memory assigning. The reason being that if fewer elements are assigned to the memory and saved within the same, then the rest of the allocated memory would go to waste. Therefore, C dynamic memory allocation declarations are used for overcoming the issues of static memory allocation. Herein, the memory is assigned as and when required and not earlier on.


Both these functions in C language - malloc and calloc – are useful for the dynamic allocation of memory space. They have quite a few differences and similarities between them. Additionally, their benefits and disadvantages can be gauged to assess which function would suit a particular C program or process.

For instance, malloc () is faster in comparison to calloc (). More so, malloc() is much easier to put into use as it requires simply one argument. Calloc() takes more time as it first initializes the memory space to ZERO and allocates the required memory to the same. The decision to use calloc or malloc would depend on the need of variable initialization and how important it is for the performance of your program – take your pick accordingly.

We shall await your comments with regards to more differences between calloc and malloc that we may have missed in the article. Do write back to us.

Related Articles