Dynamic Memory Allocation

Learn how Dynamic Memory Allocation allows C programs to request, resize, and release memory during execution using malloc(), calloc(), realloc(), and free().

Introduction

In the previous lesson, you learned that variables and arrays occupy memory. Normally, the memory required by a program is decided before the program starts. But what if a program does not know in advance how much memory it will need? For example, a student management system may need to store records for 50 students today and 500 students tomorrow. In such situations, fixed memory allocation is not sufficient. To solve this problem, C provides Dynamic Memory Allocation (DMA).

What is Dynamic Memory Allocation?

Dynamic Memory Allocation is the process of allocating and releasing memory during the execution of a program. Instead of deciding memory size before execution, the program requests memory whenever it is needed.

Why Do We Need Dynamic Memory Allocation?

Without DMA

With DMA

Real-World Analogy

Imagine visiting a hotel. You don't book every room in advance. Instead, you request a room when you arrive, use it during your stay, and return it when you leave. Dynamic memory works in exactly the same way.

Hotel (Heap Memory)

↓

Request Room (malloc)

↓

Use Room (Store Data)

↓

Checkout (free)

↓

Room Becomes Available Again

Static Memory vs Dynamic Memory

Feature	Static Memory	Dynamic Memory
Allocation Time	Before program execution	During program execution
Size	Fixed size	Flexible size
Management	Managed automatically	Managed by the programmer
Resizing	Cannot be resized	Can be allocated/resized as needed

Memory Areas in C

A C program uses different memory regions. Dynamic memory is allocated from the Heap.

Memory Layout

+----------------------+
|      Code Segment    |
+----------------------+
| Global Variables     |
+----------------------+
|       Heap           |  ← Dynamic Memory Allocation
+----------------------+
|       Stack          |  ← Local variables, function calls
+----------------------+

What is Heap Memory?

The Heap is a region of memory used for dynamic allocation. Its characteristics include:

Allocated during execution
Managed manually by the programmer
Larger than stack memory
Memory remains allocated until it is explicitly released

Dynamic Memory Functions

C provides four standard functions for dynamic memory allocation, declared in #include <stdlib.h>:

malloc()

Memory Allocation. Allocates one block of memory. Memory is not initialized. Returns the starting address.

calloc()

Contiguous Allocation. Allocates multiple memory blocks. Initializes memory to zero. Returns the starting address.

realloc()

Resize Allocation. Used to increase or decrease the size of previously allocated memory.

free()

Release Memory. Releases dynamically allocated memory back to the system so it can be reused and helps prevent memory leaks.

Dynamic Memory Allocation Process

Program Starts

↓

Request Memory

↓

Heap Allocates Memory

↓

Use Memory

↓

Release Memory (free) → Program Continues

Example: Using malloc()

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

int main()
{
    int *ptr;

    ptr = (int *)malloc(sizeof(int));

    *ptr = 100;

    printf("%d", *ptr);

    free(ptr);

    return 0;
}

Line-by-Line Explanation

Line 1-2: Headers

stdio.h is used for input and output. stdlib.h provides the dynamic memory allocation functions.

Line 6: int *ptr;

Declares a pointer named ptr. Currently, it does not point to any valid memory location.

Line 8: ptr = (int *)malloc(sizeof(int));

malloc() requests memory from the Heap. sizeof(int) determines the number of bytes required. (int *) converts the returned address into an integer pointer. The address is then stored in ptr.

Line 10: *ptr = 100;

The pointer goes to the allocated memory address and stores the value 100.

Line 12: printf("%d", *ptr);

The pointer accesses the value stored at the allocated address. Output: 100.

Line 14: free(ptr);

Releases the allocated memory. The Heap memory becomes available for future use.

Memory Before and After free()

Before free()

After free()

Advantages of Dynamic Memory Allocation

DMA provides many benefits

Efficient memory usage
Memory allocated only when required
Flexible memory management
Supports dynamic data structures
Suitable for large applications

Real-World Applications

Operating Systems

Process management and memory management.

Databases

Dynamic record storage.

Web Browsers

Tab management and cache allocation.

Games

Dynamic object creation and level loading.

Data Structures

Linked Lists, Trees, Graphs, Queues, and Stacks.

Common Beginner Mistakes

Forgetting to Release Memory

Allocated memory should always be released using free() when it is no longer needed to prevent memory leaks.

Accessing Memory After free()

Once memory has been released, it should not be accessed again. Doing so leads to undefined behavior.

Ignoring Memory Allocation Failure

malloc() may fail if sufficient memory is not available. Always verify that memory allocation was successful before using the pointer.

Confusing Stack and Heap

Stack memory is managed automatically. Heap memory is managed manually by the programmer.

Best Practices

Include <stdlib.h> when using dynamic memory functions.
Always release allocated memory with free().
Check whether memory allocation succeeds before using the pointer.
Allocate only the required amount of memory.
Avoid accessing released memory and set the pointer to NULL after freeing it.

Frequently Asked Questions

What is Dynamic Memory Allocation?

It is the process of allocating memory during program execution.

Which memory area is used for dynamic allocation?

The Heap.

Which header file provides dynamic memory functions?

#include <stdlib.h>

Which function releases dynamically allocated memory?

free().

Why is free() important?

It releases dynamically allocated memory so it can be reused and helps prevent memory leaks.

Key Takeaways

Dynamic Memory Allocation allocates memory during program execution.
The Heap is used for dynamic memory.
malloc(), calloc(), realloc(), and free() are the standard dynamic memory functions.
Dynamically allocated memory should always be released using free().
Proper memory management is essential for writing efficient and reliable C programs.

Summary

Dynamic Memory Allocation gives C programs the flexibility to request memory only when it is needed and release it when it is no longer required. By using the Heap and the standard memory management functions, programmers can build efficient applications that handle changing amounts of data. Understanding DMA is essential because it forms the foundation for advanced data structures, efficient memory management, and high-performance software development.

Next Lesson →