1. Home
c tutorial

Explore C Tutorials: From Beginner Concepts to Advanced Techniques

Dive into our C tutorials and expand your programming skills. From fundamental concepts to advanced techniques, we've got you covered. Start your journey to C mastery today

  • 130 Lessons
  • 22 Hours
right-top-arrow

Tutorial Playlist

132 Lessons
51. 

Dynamic Memory Allocation in C

Updated on 19/07/20244,112 Views
Content

Dynamic memory allocation is a crucial concept in C programming that allows you to allocate memory dynamically at runtime. Unlike static memory allocation in C, where the memory is allocated at compile-time and remains fixed, dynamic memory allocation enables you to allocate memory as per your program's requirements and release it when no longer needed. This flexibility is essential for handling variable-sized data structures and optimising memory usage.

In this tutorial, we will explore the basics of dynamic memory allocation in C, including its importance, advantages, and various dynamic memory allocation functions. We will also discuss memory leaks, their causes, detection, and prevention, and provide practical dynamic memory allocation in c programming examples to solidify your understanding.

Understanding Dynamic Memory Allocation in C

Dynamic memory allocation refers to the process of dynamically allocating and deallocating memory during a program's execution. It allows you to request memory space as per your program's requirements, use it for storing data, and release it when it is no longer needed. The dynamic memory allocation mechanism in C provides functions such as malloc(), calloc(), realloc(), and free() to manage memory dynamically.

Advantages of Dynamic Memory Allocation

Dynamic memory allocation offers several advantages over static memory allocation in C:

  1. Flexibility: Allows you to adapt your program's memory requirements based on runtime conditions. It enables you to allocate memory as per the actual data size and change it dynamically, unlike static allocation, which is fixed.
  2. Efficient memory usage: Optimizes memory usage by allocating memory only when required and releasing it when no longer needed. This dynamic management of memory prevents wastage and improves overall program efficiency.
  3. Reduced memory footprint: Unlike static allocation, where memory is reserved for the entire program execution, dynamic allocation allocates memory only when requested, enabling efficient memory sharing.
  4. Dynamic data structures: It enables the creation of data structures that can grow or shrink based on runtime needs, such as linked lists, trees, and hash tables.

How Does Memory Management in C Work?

Before we dive into dynamic memory allocation, it's essential to understand how memory management works in C. C divides memory into different segments:

  1. Text Segment: This segment stores the program's executable code.
  2. Static or Global Data Segment: It contains global variables and static variables, which are allocated memory before the program's execution starts. The memory for these variables remains constant throughout the program's execution.
  3. Stack Segment: The stack segment is used for storing function calls, local variables, and function parameters. The memory in this segment is automatically allocated and deallocated as functions are called and return.
  4. Heap Segment: The heap segment is used for dynamic memory allocation. It provides a region of memory where you can request memory space at runtime using dynamic memory allocation functions and release it when no longer needed.

Dynamic memory allocation functions, such as malloc(), calloc(), realloc(), and free(), manage memory in the heap segment.

Types of Memory in C

In C programming, memory can be broadly categorised into two types:

  1. Static Memory: Static memory refers to the memory allocated at compile-time and remains fixed throughout the program's execution. It includes global variables, static variables, and memory used by the program's executable code.
  2. Dynamic Memory: Dynamic memory refers to allocated and deallocated memory at runtime. It is used for storing data structures whose size is unknown at compile-time or needs to change dynamically during program execution.

Introduction to Dynamic Memory Allocation in C

In C, the dynamic memory allocation functions provide a way to allocate and deallocate memory dynamically during program execution. These functions reside in the <stdlib.h> header file. Let's take a closer look at each of these functions:

malloc() Function

The malloc() function is used to allocate a block of memory in the heap segment. It takes the number of bytes as an argument and returns a pointer to the allocated memory block. The syntax for malloc() function is as follows:

void* malloc(size_t size);

Here, size is the number of bytes to allocate, and the return type is void* (generic pointer).

Example:

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

int main() {
int* ptr;
int n = 5;

// Allocate memory for n integers
ptr = (int*)malloc(n * sizeof(int));

if (ptr == NULL) {
printf("Memory allocation failed\n");
return 1;
}

// Access and modify allocated memory
for (int i = 0; i < n; i++) {
ptr[i] = i + 1;
}

// Print the allocated memory
for (int i = 0; i < n; i++) {
printf("%d ", ptr[i]);
}

// Deallocate the memory
free(ptr);

return 0;
}

In this example, we allocate memory for n integers using malloc(). The size of memory to allocate is calculated using n * sizeof(int). We then assign the returned memory address to the pointer ptr. After using the allocated memory, we deallocate it using the free() function.

calloc() Function

The calloc() function is used to allocate memory and initialise it with zero. It takes two arguments: the number of elements to allocate and the size of each element. The total memory allocated by calloc() is the product of the number of elements and the size of each element. The syntax for calloc() function is as follows:

void* calloc(size_t num, size_t size);

Here, num is the number of elements to allocate, size is the size of each element, and the return type is void* (generic pointer).

Example:

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

int main() {
int* ptr;
int n = 5;

// Allocate memory for n integers and initialize with zero
ptr = (int*)calloc(n, sizeof(int));

if (ptr == NULL) {
printf("Memory allocation failed\n");
return 1;
}

// Access and modify allocated memory
for (int i = 0; i < n; i++) {
ptr[i] = i + 1;
}

// Print the allocated memory
for (int i = 0; i < n; i++) {
printf("%d ", ptr[i]);
}

// Deallocate the memory
free(ptr);

return 0;
}

In this example, we allocate memory for n integers using calloc(). The size of memory to allocate is calculated using n * sizeof(int). Unlike malloc(), calloc() initialises the allocated memory with zero. We then access and modify the allocated memory as needed and deallocate it using the free() function.

realloc() Function

The realloc() function is used to resize the previously allocated memory block. It takes two arguments: a pointer to the previously allocated memory block and the new size in bytes. The return value is a pointer to the resized memory block, which may or may not be the same as the original pointer. If the resizing fails, realloc() returns NULL without modifying the original memory block. The syntax for realloc() function is as follows:

void* realloc(void* ptr, size_t size);

Here, ptr is a pointer to the previously allocated memory block, size is the new size in bytes, and the return type is void* (generic pointer).

Example:

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

int main() {
int* ptr;
int n = 5;

// Allocate memory for n integers
ptr = (int*)malloc(n * sizeof(int));

if (ptr == NULL) {
printf("Memory allocation failed\n");
return 1;
}

// Access and modify allocated memory
for (int i = 0; i < n; i++) {
ptr[i] = i + 1;
}

// Reallocate memory for 10 integers
ptr = (int*)realloc(ptr, 10 * sizeof(int));

if (ptr == NULL) {
printf("Memory reallocation failed\n");
return 1;
}

// Access and modify reallocated memory
for (int i = n; i < 10; i++) {
ptr[i] = i + 1;
}

// Print the reallocated memory
for (int i = 0; i < 10; i++) {
printf("%d ", ptr[i]);
}

// Deallocate the memory
free(ptr);

return 0;
}

In this example, we first allocate memory for n integers using malloc(). We then access and modify the allocated memory as needed. Later, we resize the memory block using realloc() to accommodate 10 integers. The new size is calculated using 10 * sizeof(int). If the reallocation is successful, the original pointer may or may not change. Finally, we access and modify the reallocated memory and deallocate it using the free() function.

free() Function

The free() function is used to deallocate the memory previously allocated using malloc(), calloc(), or realloc(). It takes a single argument, which is a pointer to the memory block, to deallocate. The syntax for free() function is as follows:

void free(void* ptr);

Here, ptr is the pointer to the memory block to deallocate.

Example:

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

int main() {
int* ptr;
int n = 5;

// Allocate memory for n integers
ptr = (int*)malloc(n * sizeof(int));

if (ptr == NULL) {
printf("Memory allocation failed\n");
return 1;
}

// Access and modify allocated memory
for (int i = 0; i < n; i++) {
ptr[i] = i + 1;
}

// Print the allocated memory
for (int i = 0; i < n; i++) {
printf("%d ", ptr[i]);
}

// Deallocate the memory
free(ptr);

return 0;
}

In this example, we allocate memory for n integers using malloc(). After accessing and modifying the allocated memory, we deallocate it using the free() function. It is crucial to deallocate the dynamically allocated memory to prevent memory leaks.

Memory Leak and Dynamic Memory Allocation

A memory leak occurs when dynamically allocated memory is not deallocated properly after it is no longer needed. Memory leaks can occur due to several reasons, including:

  1. Forgetting to deallocate memory: If you allocate memory dynamically but forget to deallocate it using free(), a memory leak occurs.
  2. Losing the reference to allocated memory: If the pointer to dynamically allocated memory is lost or overwritten without deallocating the memory, a memory leak occurs.
  3. Premature program termination: If a program terminates prematurely without deallocating dynamically allocated memory, memory leaks can occur.

Memory leaks can result in excessive memory usage, degraded program performance, and even program crashes.

Detecting and Preventing Memory Leak

To detect and prevent memory leaks, follow these best practices:

  1. Allocate memory only when necessary: Allocate memory dynamically only when required. Avoid excessive dynamic memory allocations to minimise the chances of memory leaks.
  2. Deallocation after use: Always deallocate dynamically allocated memory using the free() function when it is no longer needed. Ensure that every malloc(), calloc(), or realloc() call is paired with a corresponding free() call.
  3. Avoid losing references: Be careful when assigning new values to pointers. Ensure that the original memory block is deallocated or copied appropriately to prevent memory leaks.
  4. Use appropriate data structures: Choose appropriate data structures that minimise memory leaks. For example, using linked lists instead of arrays can simplify memory deallocation in certain scenarios.
  5. Memory leak detection tools: Utilise memory leak detection tools and techniques, such as debugging tools or memory profiling tools, to identify and fix memory leaks in your code.

How to deallocate memory using free()

To deallocate dynamically allocated memory using the free() function, follow these steps:

  1. Ensure that you have finished using the dynamically allocated memory.
  2. Pass the pointer to the dynamically allocated memory to the free() function.
  3. After calling free(), the memory block is deallocated and can no longer be accessed.

Here's an example demonstrating how to deallocate memory using free():

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

int main() {
int* ptr;

// Allocate memory for an integer
ptr = (int*)malloc(sizeof(int));

if (ptr == NULL) {
printf("Memory allocation failed\n");
return 1;
}

*ptr = 10; // Access and modify the allocated memory

printf("Value: %d\n", *ptr);

// Deallocate the memory
free(ptr);

return 0;
}

How to deallocate memory without using free()

While it is essential to deallocate dynamically allocated memory using the free() function, there are situations where you may not be able to or need to deallocate the memory manually. In such cases, the operating system automatically reclaims the memory when the program terminates. However, relying on the operating system to deallocate memory can lead to memory leaks and is generally not recommended.

Applications of Dynamic Memory Allocation

Dynamic memory allocation finds applications in various areas of C programming, including:

  1. Data structures: Dynamic memory allocation is essential for implementing dynamic data structures such as linked lists, stacks, queues, trees, and graphs.
  2. File handling: Dynamic memory allocation is often used when reading or writing files that contain variable-sized data.
  3. Dynamic strings: Dynamic memory allocation is used for managing dynamic strings, where the length of the string can vary during runtime.
  4. Simulation and gaming: Applications involving simulations or games often require dynamic memory allocation to create and manage dynamic objects, entities, or game states.
  5. Networking: Dynamic memory allocation is employed in networking applications to manage dynamically changing buffers, message queues, or packet data.

Conclusion

Dynamic memory allocation is a crucial concept in C programming that enables flexible and efficient memory management. By using functions like malloc(), calloc(), realloc(), and free(), you can allocate memory as per your program's needs and release it when no longer required.

Ready to take your C programming skills to the next level? Explore advanced programming courses like Full Stack Software Development Program offered by upGrad and enhance your knowledge of dynamic memory allocation and other important topics in C programming.

Upgrade your skills and become a proficient C programmer today!

FAQs

Q1: What is the difference between static and dynamic memory allocation in C?

Static memory allocation in C refers to memory allocation at compile-time, where the memory is fixed and remains constant throughout the program's execution. On the other hand, dynamic memory allocation allows memory allocation and deallocation at runtime, providing flexibility in managing memory requirements.

Q2: What are the advantages of dynamic memory allocation in C?

Dynamic memory allocation offers several advantages, including flexibility in memory allocation, efficient memory usage, reduced memory footprint, and the ability to handle dynamic data structures.

Q3: How do I deallocate dynamically allocated memory in C?

To deallocate dynamically allocated memory in C, you need to use the free() function and pass it the pointer to the allocated memory block. This releases the memory and makes it available for reuse.

Test your C programming skills with a Free Quiz

image
right-top-arrowright-top-arrow
Pavan

PAVAN VADAPALLI

Director of Engineering

Director of Engineering @ upGrad. Motivated to leverage technology to solve problems. Seasoned leader for startups and fast moving orgs. Working …Read More

Popular

Need Guidance? We're Here to Help!
form image
+91
*
By clicking, I accept theT&Cand
Privacy Policy
image
Join 10M+ Learners & Transform Your Career
Learn on a personalised AI-powered platform that offers best-in-class content, live sessions & mentorship from leading industry experts.
right-top-arrowleft-top-arrow

upGrad Learner Support

Talk to our experts. We’re available 24/7.

text

Indian Nationals

1800 210 2020

text

Foreign Nationals

+918045604032

Disclaimer

upGrad does not grant credit; credits are granted, accepted or transferred at the sole discretion of the relevant educational institution offering the diploma or degree. We advise you to enquire further regarding the suitability of this program for your academic, professional requirements and job prospects before enr...