malloc() Function in C library with EXAMPLE

By : Benjamin Walker Benjamin Walker
Hours Updated

⚡ Smart Summary

malloc() in C reserves a block of memory on the heap at runtime and returns a void pointer to its first byte, letting programs request storage whose size is unknown until the code actually executes.

  • 🧠 Runtime allocation: malloc() reserves memory during execution when the required size is not known at compile time.
  • 📦 Syntax: A cast_type pointer receives malloc(byte_size), commonly sized with sizeof for portability.
  • ⚠️ NULL check: A failed request returns a NULL pointer, so validate the result before dereferencing it.
  • ➕ Pointer arithmetic: The block is contiguous, so use + rather than ++ to reach array elements.
  • 🧹 Free the memory: Release every block with free() to prevent memory leaks and dangling pointers.
  • 🤖 AI assistance: AI assistants and GitHub Copilot draft malloc() calls and flag missing free() statements.
Read More

malloc() Function in C

What is malloc in C?

The malloc() function stands for memory allocation. It is a function which is used to allocate a block of memory dynamically. It reserves memory space of specified size and returns the null pointer pointing to the memory location. The pointer returned is usually of type void. It means that we can assign malloc function to any pointer.

What is malloc in C

Syntax

ptr = (cast_type *) malloc (byte_size);

Here,

  • ptr is a pointer of cast_type.
  • The malloc function returns a pointer to the allocated memory of byte_size.
Example: ptr = (int *) malloc (50)

When this statement is successfully executed, a memory space of 50 bytes is reserved. The address of the first byte of reserved space is assigned to the pointer ptr of type int.

Consider another example of malloc implementation:

#include <stdlib.h>
int main(){
int *ptr;
ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */
    if (ptr != NULL) {
      *(ptr + 5) = 480; /* assign 480 to sixth integer */
      printf("Value of the 6th integer is %d",*(ptr + 5));
    }
}

Output:

Value of the 6th integer is 480

Notice that sizeof(*ptr) was used instead of sizeof(int) in order to make the code more robust when *ptr declaration is typecasted to a different data type later.

The allocation may fail if the memory is not sufficient. In this case, it returns a NULL pointer. So, you should include code to check for a NULL pointer.

Keep in mind that the allocated memory is contiguous and it can be treated as an array. We can use pointer arithmetic to access the array elements rather than using brackets [ ]. We advise to use + to refer to array elements because using incrementation ++ or += changes the address stored by the pointer.

Malloc function can also be used with the character data type as well as complex data types such as structures.

Why Use malloc() in C?

Static arrays and ordinary variables fix their size when the program is compiled, which wastes space when the requirement turns out smaller and fails outright when it turns out larger. malloc() solves this by requesting memory at runtime, so a program can size a buffer to the exact amount of data it receives. This runtime flexibility is the heart of dynamic memory allocation in C.

Dynamic allocation with malloc() is the right choice in several common situations:

  • The amount of input is unknown until the program runs, such as reading a file or a user-supplied list.
  • Large blocks are needed that would overflow the limited stack, since malloc() draws from the much larger heap.
  • Data must outlive the function that created it, because heap memory persists until it is explicitly released.
  • Structures and arrays need to grow or shrink while the program is executing.

Because the reserved block is handed back as a pointer, it can be passed between functions cheaply without copying the underlying data.

RELATED ARTICLES

How to Free Memory Allocated by malloc()

Memory reserved by malloc() lives on the heap and is never released automatically. When a program keeps allocating without freeing, it slowly consumes all available memory, a defect known as a memory leak. The free() function returns a finished block to the system so the space can be reused.

The free() function takes a single argument, the pointer that malloc() returned, and releases the whole block at once:

int *ptr;
ptr = malloc(10 * sizeof(int));
if (ptr != NULL) {
    /* use the allocated memory here */
    free(ptr);   /* release the block */
    ptr = NULL;  /* avoid a dangling pointer */
}

Follow these rules to manage dynamic memory safely:

  • Call free() exactly once for every successful malloc(); freeing the same block twice causes undefined behavior.
  • Set the pointer to NULL after freeing so it cannot be reused as a dangling pointer.
  • Never free() a pointer that malloc() did not return, including one shifted by pointer arithmetic.
  • Match every allocation with a matching release before the pointer goes out of scope.

Keeping allocation and release in balance is the core discipline of manual memory management in C, and it prevents both leaks and crashes caused by reusing freed memory.

malloc() vs calloc(): Key Differences

malloc() and calloc() both reserve heap memory, but they differ in their arguments and in how they treat the new block. malloc() takes one argument, the total number of bytes, and leaves the contents uninitialized, so the block holds unpredictable garbage values until the program writes to it. calloc() takes two arguments, the number of elements and the size of each, and clears every byte to zero before returning the pointer.

The practical differences come down to three points:

  • Initialization: calloc() zeroes the memory, while malloc() does not, which makes malloc() slightly faster when the values will be overwritten anyway.
  • Arguments: you write malloc(n * size) but calloc(n, size) to reserve the same array.
  • Use case: choose calloc() when a clean, zeroed block matters, and malloc() when speed is preferred and initialization is handled manually.

Both functions are declared in stdlib.h, both return a void pointer or NULL on failure, and both hand their memory back with the same free() function.

FAQs

In C the cast is optional and often discouraged, because void* converts to any object pointer automatically and an explicit cast can mask a missing stdlib.h include. In C++, however, the cast is required.

A NULL return means the request failed, usually from insufficient memory. Always check the pointer before using it, because dereferencing NULL leads to undefined behavior and typically crashes the program.

realloc() resizes a block previously reserved by malloc(), keeping existing data up to the smaller size. If it fails it returns NULL and leaves the original block intact, so assign its result to a temporary pointer first.

A memory leak happens when heap memory from malloc() is never released with free(). The program keeps reserving space it no longer uses, which can gradually exhaust the memory available to it.

malloc() reserves memory on the heap, not the stack. Heap blocks stay valid until you call free(), so they can outlive the function that created them, unlike automatic stack variables that vanish on return.

malloc() is a library function that returns void* and needs sizeof to compute bytes. C++ new is an operator that returns a typed pointer and calls constructors. Pair malloc() with free(), and new with delete.

Yes. AI coding assistants draft malloc() calls, insert NULL checks, and flag missing free() calls or leaks, and they can explain pointer arithmetic. Always compile and test the generated code before trusting it.

GitHub Copilot suggests malloc(), sizeof(), and matching free() lines from a comment describing your intent. Review each suggestion for missing NULL checks and leaks before you compile.

Summarize this post with: