# Dynamic Memory in C

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.

```c
#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.

```c
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.

```c
#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)

```c
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

```c
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:**

```c
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:**

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

### `calloc`

**Usage:**

```c
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:**

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

### `realloc`

**Usage:**

```c
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:**

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

### `free`

**Usage:**

```c
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:**

```c
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.

```c
#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.

```c
#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.

```c
#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.

```c
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.

```c
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.

```c
#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.

```c
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.

```c
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.

```c
#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:

```c
#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.

```c
#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.

```c
#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.

```c
#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:

```c
#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.