Jyotiprakash's Blog

Dynamic Memory in C

Jyotiprakash Mishra's photo
Jyotiprakash Mishra
·

22 min read

Dynamic memory in C programming refers to the manual management of memory allocation and deallocation during the runtime of a program. Unlike automatic or static memory allocation, which is managed by the compiler, dynamic memory allows a program to request and release memory as needed.

Why Dynamic Memory is Required

  1. Flexibility: Dynamic memory allocation allows programs to use memory as needed without a pre-defined limit. It is particularly useful when the amount of data is not known at compile time and can change during execution.

  2. Efficiency: By allocating only the necessary memory during runtime, dynamic memory can lead to more efficient use of memory resources, reducing the overall memory footprint of a program.

  3. Data Structures: It enables the creation and manipulation of complex data structures such as linked lists, trees, and graphs. These structures often require the ability to add and remove elements dynamically, which is facilitated by dynamic memory allocation.

  4. Scalability: Programs that can handle varying amounts of data without recompilation are more scalable. Dynamic memory allocation allows programs to adapt to the dataset's size, making them suitable for a wide range of applications.

Let's start with a basic C program. In this program, there are two functions beyond main: firstFunction and secondFunction. Each function, including main, will have its local variables. Additionally, we'll include some global variables to demonstrate how they reside in the data segment.

#include <stdio.h>

// Global variables (stored in the data segment)
int globalVar1 = 10;
int globalVar2 = 20;

// Function declarations
void secondFunction();
void firstFunction();

int main() {
    int mainLocal = 1; // Local variable for main
    printf("Main starts\n");
    firstFunction();
    printf("Main ends\n");
    return 0;
}

void firstFunction() {
    int firstLocal = 2; // Local variable for firstFunction
    printf("First function starts\n");
    secondFunction();
    printf("First function ends\n");
}

void secondFunction() {
    int secondLocal = 3; // Local variable for secondFunction
    printf("Second function starts\n");
    // Function body
    printf("Second function ends\n");
}

This program has a straightforward flow: main calls firstFunction, which in turn calls secondFunction. Each function declares and uses local variables.

Let's visualize the stack when secondFunction is running.

High Memory
                              |---------------|
                              |     ...       |  <--- Other functions and data
                              |---------------|
Global & Static Variables --> | globalVar1=10 |
                              | globalVar2=20 |
                              |---------------|    
 Heap (dynamic memory) -->    |    [empty]    |  
                              |---------------| 
                              |     ...       |  <--- Possible other stack frames
                              |---------------|
 Stack                        | secondLocal=3 |  <--- secondFunction's stack frame (currently executing)
                              |---------------|  
                              |  firstLocal=2 |  <--- firstFunction's stack frame                            
                              |---------------|
                              |  mainLocal=1  |  <--- main's stack frame
                              |---------------|
Low Memory

  • Global Variables: globalVar1 and globalVar2 are stored in the data segment and are available throughout the program execution.

  • Stack Allocation: Each function call creates a new stack frame on the stack where local variables are stored. In this illustration, mainLocal is in the main's stack frame, firstLocal is in the firstFunction's stack frame, and secondLocal is in the secondFunction's stack frame.

  • Empty Heap: The heap is shown as empty because this program does not perform dynamic memory allocation.

  • Static vs. Dynamic Allocation: Local variables (mainLocal, firstLocal, secondLocal) are statically allocated on the stack. Global variables are statically allocated in the data segment. The heap is used for dynamic memory allocation, which is not used in this example but would be relevant for managing memory at runtime.

  • Erasing Stack Allocation: When a function returns, its stack frame is "erased," meaning the space it occupied can be reused by subsequent function calls. However, the actual erasure is conceptual; the values may remain in memory until overwritten by new calls.

Let's first update the C program. In this version, secondFunction will dynamically allocate memory for 10 integers using malloc and return the pointer to this memory. firstFunction will then return this pointer back to main. Finally, main will free this allocated memory before exiting.

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

// Function declarations
int* secondFunction();
int* firstFunction();

int main() {
    int *mainPtr = NULL; // Local pointer variable for main
    printf("Main starts\n");
    mainPtr = firstFunction();
    printf("Main ends, allocated memory address: %p\n", (void*)mainPtr);
    free(mainPtr); // Freeing the dynamically allocated memory
    return 0;
}

int* firstFunction() {
    int *firstPtr = NULL; // Local pointer variable for firstFunction
    printf("First function starts\n");
    firstPtr = secondFunction();
    printf("First function ends, received memory address: %p\n", (void*)firstPtr);
    return firstPtr;
}

int* secondFunction() {
    int *secondPtr = NULL; // Local pointer variable for secondFunction
    printf("Second function starts\n");
    secondPtr = (int*)malloc(10 * sizeof(int)); // Dynamically allocating memory for 10 integers
    printf("Second function ends, allocated memory address: %p\n", (void*)secondPtr);
    return secondPtr;
}

1. When the Second Function is Running (Before Allocation)

High Memory
                              |---------------|
                              |     ...       |  <--- Other functions and data
                              |---------------|
Global & Static Variables --> | globalVar1=10 |
                              | globalVar2=20 |
                              |---------------|    
 Heap (dynamic memory) -->    |    [empty]    |  
                              |---------------| 
                              |     ...       |  <--- Possible other stack frames
                              |---------------|
 Stack                        | secondPtr=NULL|  <--- secondFunction's stack frame (currently executing)
                              |---------------|  
                              |  firstPtr=NULL|  <--- firstFunction's stack frame (waiting for return)                              
                              |---------------|
                              |  mainPtr=NULL |  <--- main's stack frame
                              |---------------|
Low Memory

2. After Allocation and When the First Function Has Returned to Main

High Memory
                              |---------------|
                              |     ...       |  <--- Other functions and data
                              |---------------|
Global & Static Variables --> | globalVar1=10 |
                              | globalVar2=20 |
                              |---------------|    
 Heap (dynamic memory) -->    |---------------| 
                              |   10 ints     |  <--- Dynamically allocated (e.g., at address 0x561a)
                              |  (0x561a...)  |  
                              |---------------|  
                              |    [empty]    |  
                              |---------------| 
 Stack                        |               |  
                              |     ...       |  <--- (firstPtr and secondPtr stack frames destroyed)
                              |---------------|
                              | mainPtr=0x561a| <--- main's stack frame (holds address of allocated memory)
                              |---------------|
Low Memory

  • Before Allocation: All local pointer variables (mainPtr, firstPtr, secondPtr) are initialized to NULL and reside in their respective stack frames. The heap is empty as no allocation has occurred yet.

  • After Allocation: secondFunction has allocated memory on the heap for 10 integers and stored the starting address of this allocated memory in secondPtr, which is then returned up the call chain. When main receives this address in mainPtr, the stack frames for firstFunction and secondFunction have been destroyed, but the pointer mainPtr in main’s stack frame still holds the heap address.

  • Dynamic vs. Stack Allocation: The local pointer variables are allocated on the stack and are destroyed when their functions return. However, the memory they point to on the heap remains allocated until explicitly freed (as done in main with free(mainPtr)).

  • Memory Management: The example emphasizes the distinction between the lifetime of stack-allocated variables (which are automatically destroyed when their function returns) and heap-allocated memory (which persists until it is explicitly freed).

  • Heap Area: The dynamically allocated area for 10 integers on the heap is represented with a sample address (e.g., 0x561a). This memory persists beyond the lifetime of the functions that initiated the allocation.

Dynamic memory allocation in C is managed through a set of functions provided by the C standard library (stdlib.h). These functions allow programs to allocate, reallocate, and free memory during runtime, offering flexibility for managing memory according to the program's needs. Here, we'll discuss the most common functions used for dynamic memory allocation: malloc, calloc, realloc, and free, along with their usage and detailed explanations.

malloc

Usage:

void* malloc(size_t size);

  • Description: malloc stands for memory allocation. It allocates a single block of memory of the specified size bytes. The initial content of the memory is not initialized, meaning it contains "garbage" values.

  • Parameters: size - the number of bytes to allocate.

  • Return Value: On success, returns a pointer to the allocated memory block. On failure, returns NULL.

Example:

int* ptr = (int*)malloc(10 * sizeof(int)); // Allocates memory for an array of 10 integers.

calloc

Usage:

void* calloc(size_t num, size_t size);

  • Description: calloc stands for contiguous allocation. It allocates memory for an array of num elements, each size bytes long, and initializes all bytes in the allocated storage to zero.

  • Parameters: num - the number of elements to allocate. size - the size of each element.

  • Return Value: On success, returns a pointer to the allocated memory block, which is initialized to zero. On failure, returns NULL.

Example:

int* ptr = (int*)calloc(10, sizeof(int)); // Allocates and zeros memory for an array of 10 integers.

realloc

Usage:

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

  • Description: realloc is used to resize a previously allocated memory block. It attempts to change the size of the memory block pointed to by ptr to size bytes. The contents will be unchanged to the minimum of the old and new sizes.

  • Parameters: ptr - a pointer to the memory block to be reallocated. If ptr is NULL, realloc behaves like malloc. size - the new size for the memory block, in bytes.

  • Return Value: On success, returns a pointer to the newly allocated memory block (which may be the same as ptr or a new location). On failure, returns NULL.

Example:

ptr = realloc(ptr, 20 * sizeof(int)); // Resizes the previously allocated block to hold 20 integers.

free

Usage:

void free(void* ptr);

  • Description: free deallocates the memory block pointed to by ptr, which must have been returned by a previous call to malloc, calloc, or realloc. After free, the memory block pointed to by ptr is no longer available to the program.

  • Parameters: ptr - a pointer to the memory block to be freed. If ptr is NULL, no action occurs.

  • Return Value: None.

Example:

free(ptr); // Frees the allocated memory pointed by ptr.

Here's an example C program that demonstrates dynamic memory allocation for an integer array. The size of the array is determined by user input. This program allocates memory for the array, fills it with values, prints the array, and then frees the allocated memory. Each step is accompanied by a brief explanation.

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

int main() {
    int n, i;
    int *arr;

    printf("Enter the number of elements: ");
    scanf("%d", &n);

    // Dynamically allocate memory using malloc
    arr = (int*)malloc(n * sizeof(int)); // Allocates memory for n integers

    // Check if the memory has been successfully allocated
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1; // Return with error code
    }

    // Input elements in the array
    for (i = 0; i < n; i++) {
        printf("Enter element %d: ", i + 1);
        scanf("%d", &arr[i]);
    }

    // Display the array
    printf("Array elements: ");
    for (i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // Free the allocated memory
    free(arr);

    return 0; // Return success
}

  • Memory Allocation: After reading the number of elements (n) from the user, the program allocates memory to hold n integers using malloc. The size required is n * sizeof(int) to ensure enough space is allocated for n integers.

  • Memory Allocation Check: The return value from malloc is checked to ensure that the memory allocation was successful. If malloc returns NULL, it indicates that the allocation failed, perhaps due to insufficient memory, and the program prints an error message and exits with an error code.

  • Using the Allocated Memory: The program then enters a loop to prompt the user for the array's elements, storing them in the allocated space. Another loop is used to print these values, demonstrating how the dynamically allocated memory is accessed and used just like a regular array.

  • Freeing Memory: Finally, free(arr) is called to deallocate the memory that was previously allocated for the array. This step is crucial to prevent memory leaks, ensuring that all dynamically allocated memory is returned to the system for future use.

  • Returning from main: The program returns 0 to indicate successful execution.

This example demonstrates dynamic memory allocation for a string (character array) based on user input. It allows the user to input a string of arbitrary length, ensuring that the allocated memory is sufficient to hold the input by reallocating more space as needed. Finally, the program frees the allocated memory. The example includes checking the input size against the currently allocated space and reallocating memory if necessary.

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

int main() {
    char *str = NULL;
    int len = 0, capacity = 1; // Initial capacity for 1 char (null terminator)
    char input[256]; // Buffer for user input, assuming a reasonable max length for a single input

    // Initially allocate memory for the string
    str = (char*)malloc(sizeof(char) * capacity);
    if (str == NULL) {
        printf("Failed to allocate memory.\n");
        return 1;
    }
    str[0] = '\0'; // Ensure the string is initially empty

    printf("Enter parts of the string, one line at a time. Enter 'done' to finish:\n");

    while (1) {
        fgets(input, sizeof(input), stdin); // Read a line of input
        input[strcspn(input, "\n")] = 0; // Remove newline character

        if (strcmp(input, "done") == 0) { // Check if the user is done entering parts
            break;
        }

        len += strlen(input); // Update the required length
        if (len + 1 > capacity) { // +1 for the null terminator
            // Increase capacity to ensure it's enough for the new part plus null terminator
            capacity = len + 1;
            char *temp = realloc(str, capacity * sizeof(char));
            if (temp == NULL) {
                printf("Failed to reallocate memory.\n");
                free(str); // Free the originally allocated memory before exiting
                return 1;
            }
            str = temp;
        }

        strcat(str, input); // Append the new part to the string
    }

    printf("Your entered string: %s\n", str);

    free(str); // Free the allocated memory
    return 0;
}

  • Initial Memory Allocation: The program starts by allocating memory for a single character (capacity = 1), enough to store the null terminator, ensuring we have a valid string from the start.

  • User Input: It reads parts of the string from the user one line at a time, using a buffer input with a fixed size. The program uses fgets for reading, which includes the newline character in the input buffer. This newline character is replaced with a null terminator to correctly end the string.

  • Checking and Reallocating Memory: Before appending new input, the program checks if the current capacity of str is sufficient to hold the new data including the null terminator. If not, it increases the capacity to the new required length and uses realloc to request more memory. realloc is smart enough to try to extend the existing memory block or move it to a new location if necessary. If realloc fails, the program frees the originally allocated memory and exits.

  • Appending Input: The new input is concatenated to the existing string using strcat, assuming there's now enough space to hold the new content.

  • Termination and Cleanup: The loop breaks when the user enters "done". The program prints the complete input string and then frees the dynamically allocated memory to prevent memory leaks.

  • Memory Management: This example highlights the dynamic nature of memory management in C, specifically for handling user input of variable length. It demonstrates checking memory needs against current allocation, reallocating memory as necessary, and the importance of cleaning up allocated memory to avoid leaks.

This example program demonstrates a function that dynamically creates a structure, returns a pointer to it, and then the caller uses the data within the structure before freeing it. We'll use a simple structure for demonstration purposes.

First, let's define a simple structure that our function will create and return. For this example, we'll use a Person structure that contains a name and an age.

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

typedef struct {
    char name[50];
    int age;
} Person;

Next, we define a function that dynamically allocates a Person structure, initializes its fields, and returns a pointer to it.

Person* createPerson(const char* name, int age) {
    // Dynamically allocate memory for a new Person structure
    Person* newPerson = (Person*)malloc(sizeof(Person));
    if (newPerson == NULL) {
        printf("Memory allocation failed.\n");
        return NULL; // Return NULL if memory allocation fails
    }

    // Initialize structure fields
    strncpy(newPerson->name, name, sizeof(newPerson->name));
    newPerson->name[sizeof(newPerson->name) - 1] = '\0'; // Ensure null-termination
    newPerson->age = age;

    return newPerson; // Return the pointer to the newly created Person structure
}

In the main function, we call createPerson, use the returned structure, and then free the allocated memory.

int main() {
    // Create a new Person instance dynamically
    Person* person = createPerson("John Doe", 30);
    if (person != NULL) {
        // Use the person's data
        printf("Name: %s, Age: %d\n", person->name, person->age);

        // Free the dynamically allocated memory
        free(person);
    } else {
        printf("Failed to create a new person.\n");
    }

    return 0;
}

  • Structure Definition: The Person structure is defined with two fields: name (a string) and age (an integer).

  • Function createPerson:

    • Dynamically allocates memory for a Person structure using malloc.

    • Checks if the memory allocation was successful. If not, it returns NULL.

    • Initializes the name and age fields of the Person structure. The name is safely copied using strncpy to prevent buffer overflows, and explicitly null-terminated to ensure it's a valid string.

    • Returns a pointer to the newly allocated and initialized Person structure.

  • Main Function:

    • Calls createPerson to create a new Person instance dynamically.

    • Checks if the function successfully returned a new Person instance. If so, it uses the structure's data (prints the person's name and age).

    • Frees the dynamically allocated Person structure to avoid memory leaks.

Here's an example C program that demonstrates allocating memory for an array of structures, using the array, and then freeing the allocated memory. We will use a simple Student structure for this example, which contains a student's ID and grade.

First, let's define the Student structure.

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

typedef struct {
    int id;
    float grade;
} Student;

We will write a function to allocate memory for an array of Student structures and return a pointer to the first element of the array.

Student* createStudentArray(int numStudents) {
    // Dynamically allocate memory for the array of Student structures
    Student* students = (Student*)malloc(numStudents * sizeof(Student));
    return students; // Return the pointer to the array
}

In the main function, we allocate an array of Student structures, populate it with data, display the data, and finally, free the allocated memory.

int main() {
    int numStudents = 3; // Example number of students
    Student* students = createStudentArray(numStudents);

    // Check if memory allocation was successful
    if (students == NULL) {
        printf("Memory allocation failed.\n");
        return 1;
    }

    // Populate the array with student data
    for (int i = 0; i < numStudents; i++) {
        students[i].id = i;
        students[i].grade = (float)(90 + i); // Example grade
    }

    // Display the array contents
    for (int i = 0; i < numStudents; i++) {
        printf("Student ID: %d, Grade: %.2f\n", students[i].id, students[i].grade);
    }

    // Free the dynamically allocated memory for the array
    free(students);

    return 0;
}

  • Structure Definition: The Student structure contains two fields: id (an integer) and grade (a float).

  • Function createStudentArray:

    • Takes the number of students as an input and dynamically allocates memory for an array of Student structures of that size.

    • Uses malloc to allocate the memory, calculating the total size by multiplying the number of students by the size of the Student structure.

    • Returns a pointer to the first element of the dynamically allocated array. If allocation fails, malloc returns NULL.

  • Main Function:

    • Calls createStudentArray to dynamically allocate memory for an array of Student structures.

    • Checks if memory allocation was successful. If not, it prints an error message and returns 1.

    • Populates the array with student data using a loop. In a real-world application, this data could come from user input or a file.

    • Uses another loop to display the contents of the array, demonstrating how to access elements in a dynamically allocated array of structures.

    • Frees the dynamically allocated memory for the array of structures using free, which is crucial to avoid memory leaks.

Dynamic memory management is a critical aspect of programming in C, requiring careful allocation, use, and deallocation to avoid common pitfalls such as memory leaks, dangling pointers, and undefined behavior. I'll demonstrate this with an example that includes common mistakes and their corrections, along with detailed explanations.

First, let's start with a piece of code that illustrates some typical issues.

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

int main() {
    int* ptr = (int*)malloc(10 * sizeof(int)); // Allocate memory for an array of 10 integers

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

    for(int i = 0; i < 10; i++) {
        ptr[i] = i; // Initialize array
    }

    free(ptr); // Correctly freeing the allocated memory
    *ptr = 20; // Mistake: Accessing memory after it has been freed

    int* anotherPtr = (int*)malloc(10 * sizeof(int)); // Allocate memory again
    // Forgot to check if malloc failed here

    for(int i = 0; i < 10; i++) {
        printf("%d ", anotherPtr[i]); // Mistake: Using uninitialized memory
    }

    free(anotherPtr); // Correctly freeing the second allocation

    return 0;
}

  1. Accessing Freed Memory: The line *ptr = 20; attempts to write to memory that has already been freed by a previous call to free(ptr);. Accessing memory after it has been freed can lead to undefined behavior, including crashes or data corruption.

  2. Not Checking malloc Return Value (Second Allocation): The second call to malloc does not include a check to see if it returns NULL, which indicates a failure to allocate memory. Failing to check this can lead to dereferencing a NULL pointer if the memory allocation fails.

  3. Using Uninitialized Memory: The program prints the contents of anotherPtr array without initializing it first. Reading uninitialized memory is undefined behavior and can result in unpredictable output.

Here's how you can correct the issues identified above:

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

int main() {
    int* ptr = (int*)malloc(10 * sizeof(int)); // Allocate memory for an array of 10 integers

    if (ptr == NULL) {
        printf("Memory allocation failed.\n");
        return 1; // Early return if memory allocation fails
    }

    for(int i = 0; i < 10; i++) {
        ptr[i] = i; // Initialize array
    }

    free(ptr); // Free the allocated memory

    // Correct approach: Do not access memory after it has been freed.
    // So, the line *ptr = 20; is removed.

    int* anotherPtr = (int*)malloc(10 * sizeof(int)); // Allocate memory again

    if (anotherPtr == NULL) {
        printf("Memory allocation failed.\n");
        // Since ptr is already freed, we just return here
        return 1; // Early return if memory allocation fails
    }

    // Correct approach: Initialize or reset the memory before use.
    for(int i = 0; i < 10; i++) {
        anotherPtr[i] = i; // Correctly initializing the memory
    }

    for(int i = 0; i < 10; i++) {
        printf("%d ", anotherPtr[i]); // Now we are printing initialized memory
    }
    printf("\n");

    free(anotherPtr); // Correctly freeing the second allocation

    return 0;
}

  • Removed Access After Free: The corrected code does not attempt to access or modify memory after it has been freed, avoiding undefined behavior.

  • Added Check for malloc Failure: The second call to malloc now includes a check for a NULL return value. This ensures the program handles memory allocation failures gracefully.

  • Initialized Memory Before Use: Before using the allocated memory pointed to by anotherPtr, the corrected code initializes it. This prevents undefined behavior from reading uninitialized memory and ensures predictable program output.

For this other example, we'll examine a scenario involving dynamic allocation for a structure and its elements, demonstrating both a common mistake and its correction. This example will highlight the necessity of careful dynamic memory management, especially when dealing with nested structures or arrays within structures.

Let's consider a program that creates a dynamic array of structures, each holding a pointer to a dynamically allocated string. The program will mistakenly leak memory due to improper deallocation.

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

typedef struct {
    char* name; // Pointer to a dynamically allocated string
    int age;
} Person;

int main() {
    int n = 2; // Suppose we want an array of 2 Persons
    Person* people = (Person*)malloc(n * sizeof(Person)); // Allocate array of structures

    for (int i = 0; i < n; i++) {
        people[i].name = (char*)malloc(50 * sizeof(char)); // Allocate name string
        snprintf(people[i].name, 50, "Person %d", i + 1); // Assign a name
        people[i].age = 20 + i; // Assign an age
    }

    for (int i = 0; i < n; i++) {
        printf("Name: %s, Age: %d\n", people[i].name, people[i].age);
    }

    // Mistake: Forgetting to free the allocated strings within each structure
    free(people); // Only frees the array of structures, not the strings within

    return 0;
}

The memory allocated for each Person's name is not freed before the program ends. While the array of Person structures (people) is freed, the dynamically allocated strings pointed to by name in each structure are not, leading to memory leaks.

The corrected code includes the necessary steps to free all dynamically allocated memory, including the strings within each structure.

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

typedef struct {
    char* name; // Pointer to a dynamically allocated string
    int age;
} Person;

int main() {
    int n = 2; // Suppose we want an array of 2 Persons
    Person* people = (Person*)malloc(n * sizeof(Person)); // Allocate array of structures

    if (people == NULL) {
        printf("Failed to allocate memory for people.\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        people[i].name = (char*)malloc(50 * sizeof(char)); // Allocate name string
        if (people[i].name == NULL) {
            printf("Failed to allocate memory for name.\n");
            // Correct approach: Free already allocated memory before exiting
            for (int j = 0; j < i; j++) {
                free(people[j].name);
            }
            free(people);
            return 1;
        }
        snprintf(people[i].name, 50, "Person %d", i + 1); // Assign a name
        people[i].age = 20 + i; // Assign an age
    }

    for (int i = 0; i < n; i++) {
        printf("Name: %s, Age: %d\n", people[i].name, people[i].age);
    }

    // Correct approach: Free each allocated string within the structures
    for (int i = 0; i < n; i++) {
        free(people[i].name);
    }
    free(people); // Free the array of structures

    return 0;
}

  • Memory Allocation Checks: The corrected code includes checks after each malloc call to ensure memory was successfully allocated. If allocation fails, it frees any previously allocated memory before exiting to prevent leaks.

  • Freeing Nested Allocations: Before freeing the array of Person structures, the corrected code iterates through each structure to free the dynamically allocated string pointed to by name. This ensures that all allocated memory is properly deallocated, preventing memory leaks.

Next, we'll use a simple scenario where a function allocates memory for a structure and returns a pointer to it. The calling function then forgets to free this memory.

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

typedef struct {
    int id;
    char name[100];
} Employee;

// Function that dynamically allocates memory for an Employee structure and returns it
Employee* createEmployee(int id, const char* name) {
    Employee* newEmp = (Employee*)malloc(sizeof(Employee));
    if (newEmp == NULL) {
        printf("Memory allocation failed.\n");
        return NULL;
    }
    newEmp->id = id;
    strncpy(newEmp->name, name, sizeof(newEmp->name) - 1);
    newEmp->name[sizeof(newEmp->name) - 1] = '\0'; // Ensure null termination
    return newEmp;
}

int main() {
    Employee* emp = createEmployee(1, "John Doe");
    if (emp != NULL) {
        printf("Employee: %d, %s\n", emp->id, emp->name);
        // Memory leak: Forgot to free the memory allocated for emp
    }
    // Correct code should have: free(emp);
    return 0;
}

The createEmployee function correctly allocates memory for an Employee structure, initializes it, and returns a pointer to it. However, the calling code in main neglects to free this memory after it's done using the Employee structure. This omission is a memory leak because the allocated memory is no longer accessible after main returns, yet it remains allocated until the program terminates. Memory leaks can cause serious issues in long-running programs by gradually consuming all available memory.

Here's how the code should be corrected to avoid the memory leak:

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

typedef struct {
    int id;
    char name[100];
} Employee;

Employee* createEmployee(int id, const char* name) {
    Employee* newEmp = (Employee*)malloc(sizeof(Employee));
    if (newEmp == NULL) {
        printf("Memory allocation failed.\n");
        return NULL;
    }
    newEmp->id = id;
    strncpy(newEmp->name, name, sizeof(newEmp->name) - 1);
    newEmp->name[sizeof(newEmp->name) - 1] = '\0';
    return newEmp;
}

int main() {
    Employee* emp = createEmployee(1, "John Doe");
    if (emp != NULL) {
        printf("Employee: %d, %s\n", emp->id, emp->name);
        free(emp); // Correctly freeing the memory allocated for emp
    }
    return 0;
}

The corrected code includes a call to free(emp); in main after the Employee structure is no longer needed. This ensures that the memory allocated by createEmployee is properly released back to the system, avoiding a memory leak.

Always remember to free dynamically allocated memory once you're done with it, especially when the allocation is done inside another function. This practice is crucial for preventing memory leaks and ensuring efficient memory usage in your programs.