Dynamic Memory Management in C

The Heap and Dynamic Allocation Toolkit

So far, the variables and arrays we've worked with have been created on the stack (local variables in functions) or in static/global data segments. Stack memory is managed automatically; it's allocated when a function is called and deallocated when the function returns. Dynamic memory management operates differently, using a large pool of memory called the heap. You, the programmer, are in complete control of requesting blocks from the heap and must explicitly return them when you're done.

The following video from mycodeschool provides a comprehensive overview of the four essential functions for this task.

Let's consolidate the key points. All these functions are declared in the <stdlib.h> header.

• void* malloc(size_t size): Allocates a single block of size bytes. The memory is not initialized; it contains garbage values. It returns a void* pointer to the block, which you must cast to the appropriate pointer type. If it fails, it returns NULL.

  • Usage: int *p = (int*) malloc(10 * sizeof(int));

• void* calloc(size_t num, size_t size): Allocates memory for an array of num elements, each of size bytes. The memory is initialized to zero.

  • Usage: int *p = (int*) calloc(10, sizeof(int));

• void* realloc(void* ptr, size_t new_size): Changes the size of the memory block pointed to by ptr to new_size.

  • If new_size > old size, the extra memory is not initialized.
  • If new_size < old size, the data at the end is truncated.
  • The function may move the memory block to a new location if it cannot be expanded in place. It copies the old data to the new location. If it moves the block, the original pointer ptr becomes invalid.
  • If it fails, it returns NULL, and the original block at ptr is not freed.

• void free(void* ptr): Deallocates the memory block pointed to by ptr. The pointer ptr must be one that was returned by malloc, calloc, or realloc.

The Peril of Memory Leaks

With the power of dynamic allocation comes the responsibility of manual memory management. Forgetting to deallocate memory that is no longer needed leads to a serious problem known as a memory leak.

A memory leak occurs when a program allocates memory on the heap but loses all pointers to that memory, making it impossible to free(). This "orphaned" memory remains consumed by your program but is unusable, causing the program's memory footprint to grow over time. In long-running applications like servers, this can eventually exhaust all available system memory and crash the system.

The next video provides an excellent practical demonstration of a memory leak and how to fix it.

In GATE questions, memory leaks are often created in subtle ways:

• A pointer is overwritten with a new address from malloc before the old memory it was pointing to is freed.
• A local pointer inside a function allocates memory, but the function returns without returning the pointer, orphaning the memory block.

The Danger of Dangling Pointers

The flip side of a memory leak is a dangling pointer. This is a pointer that continues to point to a memory location that has already been deallocated by a call to free() or realloc().

Using a dangling pointer leads to undefined behavior, one of the most treacherous types of bugs in C. The program might crash, or it might appear to work correctly sometimes but fail unpredictably. This happens because the memory manager might have already allocated that same piece of memory for a different purpose. Writing through a dangling pointer can corrupt unrelated data, leading to bugs that are extremely difficult to trace.

Here’s a classic example:

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

int main() {
    int *p = (int*) malloc(sizeof(int));
    *p = 123;

    printf("Address: %p, Value: %d\n", p, *p); // Works fine

    free(p); // The memory is deallocated. p is now a dangling pointer.

    // The line below is UNDEFINED BEHAVIOR.
    // It might print 123, print garbage, or crash the program.
    printf("Accessing freed memory. Value: %d\n", *p); 
    
    *p = 456; // Even worse! Corrupting memory that may now belong to something else.

    return 0;
}

Best Practice: To mitigate the risk of dangling pointers, it's a good habit to set a pointer to NULL immediately after freeing it.

free(p);
p = NULL; // Now p is not dangling.

If you later accidentally try to dereference a NULL pointer, your program will almost certainly crash immediately with a clear error (like a "segmentation fault"), which is far easier to debug than silent data corruption.

Dangling pointers can also be created by realloc. If realloc moves a memory block to a new location, any other pointers that were holding the old address become dangling.

Conclusion

In this lesson, we transitioned from accessing pre-allocated memory to managing it dynamically. This skill is essential for writing sophisticated programs where data requirements are not fixed at compile time.

Key Takeaways:

• Dynamic memory is allocated from the heap using malloc, calloc, and realloc.
• malloc allocates uninitialized memory, while calloc allocates zero-initialized memory.
• realloc resizes memory blocks and may move them.
• It is the programmer's absolute responsibility to release memory back to the heap using free().
• A memory leak occurs when allocated heap memory becomes unreachable (orphaned) because no pointers refer to it anymore.
• A dangling pointer points to memory that has already been freed, and using it results in undefined behavior. Setting freed pointers to NULL is a valuable defensive practice.

You now have the tools to create arrays, strings, and other data structures of any size at runtime. Our next lesson, "Arrays & Strings," will build directly on this foundation. We will explore the standard C library functions for string manipulation (like strlen, strcpy, strcmp) and see how they operate on both statically and dynamically allocated character arrays.