Difference Between malloc and calloc in C

By the end of this page, you will understand how malloc and calloc differ in C, especially in how they allocate and initialize memory. You will also learn when each one is appropriate, what happens to the allocated memory, and how to avoid common bugs when working with dynamic memory.

In C, both malloc and calloc are used to allocate memory dynamically from the heap.

The key difference is this:

• malloc allocates a block of memory of a given size.
• calloc allocates memory for an array of elements and sets all bytes to zero.

What malloc does

malloc takes one argument: the total number of bytes to allocate.

char **Copyptr = malloc(MAXELEMS * sizeof(char *));

This means:

• reserve enough memory for MAXELEMS pointers to char
• do not initialize that memory

The contents of that memory are indeterminate. Reading from it before writing to it is a bug.

What calloc does

calloc takes two arguments:

1. number of elements

Think of dynamic memory like getting storage boxes.

• malloc gives you an empty box, but whatever dust or leftover labels are inside are not cleaned out.
• calloc gives you the same box, but it has been wiped clean and reset to all zeros before you receive it.

If you are going to completely refill the box right away, malloc is often fine. If you want a clean starting state so nothing accidental is left behind, calloc is safer.

Core syntax

void *malloc(size_t size);
void *calloc(size_t count, size_t size);

Example with malloc

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

int main(void) {
    int *numbers = malloc(5 * sizeof(int));
    if (numbers == NULL) {
        return 1;
    }

    for (int i = 0; i < 5; i++) {
        numbers[i] = i + 1;
    }

    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }

    free(numbers);
     ;
}

Trace example

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

int main(void) {
    int *a = malloc(3 * sizeof(int));
    int *b = calloc(3, sizeof(int));

    if (a == NULL || b == NULL) {
        free(a);
        free(b);
        return 1;
    }

    a[0] = 10;
    a[1] = 20;
    a[2] = 30;

    printf("a: %d %d %d\n", a[0], a[1], a[2]);
    printf("b: %d %d %d\n", b[0], b[1], b[2]);

    free(a);
    free(b);
    return 0;
}

When malloc is commonly used

• Allocating a buffer that will be filled immediately from a file or socket
• Creating arrays that will be initialized in a loop right after allocation
• Performance-sensitive code where zeroing memory would be unnecessary work

Example:

char *buffer = malloc(1024);
if (buffer == NULL) {
    return 1;
}
/* read data into buffer */

When calloc is commonly used

• Creating arrays of counters that should start at zero
• Allocating pointer arrays where empty entries should begin cleared
• Building structs that rely on a clean default state
• Temporary tables, matrices, or lookup arrays

Example:

int *counts = calloc(26, sizeof(int));
if (counts == NULL) {
    return 1;
}

This is useful in tasks like counting letters, frequencies, or occurrences.

Example with pointer arrays

In real C projects, developers choose between malloc and calloc based on initialization needs and readability.

Common patterns

1. Arrays that should start empty

char **items = calloc(count, sizeof(*items));
if (items == NULL) {
    return NULL;
}

This is common for:

• arrays of pointers
• tables of counters
• state-tracking arrays

2. Immediate overwrite after allocation

char *buffer = malloc(size);
if (buffer == NULL) {
    return NULL;
}

This is common when:

• reading into a buffer
• decoding binary data
• receiving network packets

3. Guard clauses for allocation failure

int *values = calloc(n, sizeof(*values));
if (values == NULL) {
    (, );
     ;
}

1. Reading malloc memory before writing to it

Broken code:

int *arr = malloc(5 * sizeof(int));
printf("%d\n", arr[0]);

Problem:

• arr[0] is uninitialized
• reading it is undefined behavior

Fix:

int *arr = malloc(5 * sizeof(int));
if (arr == NULL) {
    return 1;
}
for (int i = 0; i < 5; i++) {
    arr[i] = 0;
}

Or use calloc.

2. Forgetting to check for NULL

Broken code:

int *arr = (, ());
arr[] = ;

malloc vs calloc vs realloc

Quick reference

ptr = malloc(n * sizeof(*ptr));
ptr = calloc(n, sizeof(*ptr));

Main difference

• malloc: allocates memory, leaves it uninitialized
• calloc: allocates memory, sets all bytes to zero

Good defaults

• Use calloc for arrays of counters, flags, or pointer slots
• Use malloc for buffers that will be filled immediately

Always do this

int *arr = calloc(n, sizeof(*arr));
if (arr == NULL) {
    /* handle failure */
}

Prefer this style

int *arr = malloc(n * sizeof(*arr));

Instead of:

int *arr = malloc(n * ());

Is calloc always better than malloc?

No. calloc is better when you want zero-initialized memory. malloc is better when you will immediately write your own values into the memory.

Does calloc set everything to NULL?

It sets all bytes to zero. In practice this is often used for pointer arrays, but conceptually calloc guarantees zeroed storage, not high-level program meaning for every type in every abstract sense.

Is calloc slower than malloc?

It can be, because it initializes memory. But real performance depends on the system allocator and usage pattern. Choose based on correctness first.

Should I cast the result of malloc or calloc in C?

In C, usually no. The returned void * is automatically converted to the target pointer type. Casting can hide missing headers.

Why does calloc take two arguments?

It is designed for allocating arrays: number of elements and size of each element.

Can I replace with ?

• free — releases dynamically allocated memory.
• realloc — resizes an existing allocation.
• pointers — both functions return pointers to allocated memory.
• heap memory — malloc and calloc allocate memory from the heap.
• stack vs heap — helps explain where dynamic memory lives.
• sizeof — used to calculate correct allocation sizes.
• null pointer — important when checking allocation failure.
• undefined behavior — reading uninitialized memory is a common example.
• arrays and pointer arithmetic — useful when accessing allocated blocks.