What is Memory Leak? How can we avoid?

In C, memory leak occurs when a program allocates memory dynamically (using functions like malloc(), calloc(), or realloc()) but fails to deallocate it using free() when the memory is no longer needed. Eventually, in the worst case, too much of the available memory may become allocated, all or part of the system or device stops working correctly, the application fails, or the system slows down vastly.

Example of Memory Leak

The below example shows the memory leak concept.

#include <stdlib.h>

void f() {
  
  	// Allocate memory
    int* ptr = (int*)malloc(sizeof(int));

    // Return without freeing ptr
    return;
}

Memory allocated successfully

Explanation: Memory for an array of 10 integers is allocated using malloc(), but the memory is never freed using free(). This results in a memory leak since the allocated memory is no longer accessible but remains occupied.

Common Causes of Memory Leak

Following are the most common causes of memory leak in C:

• When dynamically allocated memory is not freed up by calling free then it leads to memory leaks. Always make sure that for every dynamic memory allocation using malloc or calloc, there is a corresponding free call.
• When track of pointers that references to the allocated memory is lost then it may happen that memory is not freed up. Hence keep the track of all pointers and make ensure that memory is freed.
• When the program terminates abruptly and the allocated memory is not freed or if any part of code prevents the call of free then memory leaks may happen.

How to avoid memory leaks?

• Manual memory management: Always ensure that free() is called for each dynamically allocated memory block once it is no longer needed. This is a fundamental practice for avoiding memory leaks.
• Use memory analysis tools: Tools like Valgrind and AddressSanitizer can help detect memory leaks by analyzing a program’s memory usage during runtime.
• Code review: Regular code reviews and static analysis tools can help spot potential issues related to memory management.
• Avoid unnecessary allocations: Only allocate memory when necessary, and ensure that every allocation has a corresponding deallocation.

Example

The below program shows the memory allocated in the heap is released to avoid memory leak.

#include <stdlib.h>

void f() {
    int* ptr = (int*)malloc(sizeof(int));

    // Do some work

    // Memory allocated by malloc is released
    free(ptr);
    return;
}

Memory allocated successfully

Explanation: This code dynamically allocates memory for an array of 10 integers using malloc(). It checks if the memory allocation is successful and prints a message accordingly. After using the memory, it is freed using free() to prevent memory leaks, and the program exits successfully with a return value of 0.

Conclusion

In conclusion, memory leaks can occur when we allocate memory on the heap but forget to release it or free it. Due to memory leaks, we may experience performance degradation and system becomes unstable. Memory leaks cause more damage for long-running programs like servers. To avoid memory leaks we must free dynamically allocated memory by calling functions like free().

GeeksforGeeks

Improve

Article Tags :

• Articles
• C Language
• C-Dynamic Memory Allocation
• C-Pointers