C Reallocate Memory

Efficient memory management is a crucial aspect of programming in C, especially when working with dynamic memory allocation. The realloc() function allows you to resize previously allocated memory blocks, making it a vital tool for managing resources effectively. This guide by The Coding College explains how to use realloc(), its benefits, and best practices for avoiding memory issues.

Understanding Dynamic Memory Allocation

In C, dynamic memory is allocated using functions like malloc(), calloc(), and realloc() from the <stdlib.h> library. Unlike static allocation, dynamic memory allows you to allocate memory during runtime, offering flexibility in managing resources.

However, when the size of an allocated memory block needs to change, the realloc() function comes into play.

What Is realloc()?

The realloc() function adjusts the size of a previously allocated memory block. It can either:

  1. Increase the size to accommodate more data.
  2. Decrease the size to optimize memory usage.

If the reallocation is successful, realloc() returns a pointer to the new memory block. If it fails, it returns NULL.

Syntax:

void* realloc(void* ptr, size_t new_size);
  • ptr: A pointer to the previously allocated memory block.
  • new_size: The new size of the memory block in bytes.

Using realloc()

Example 1: Resizing an Array

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

int main() {
    int *arr = malloc(3 * sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // Assign initial values
    for (int i = 0; i < 3; i++) {
        arr[i] = i + 1;
    }

    // Reallocate memory for 5 integers
    arr = realloc(arr, 5 * sizeof(int));
    if (arr == NULL) {
        printf("Memory reallocation failed!\n");
        return 1;
    }

    // Assign new values to the extended part
    for (int i = 3; i < 5; i++) {
        arr[i] = i + 1;
    }

    // Print the array
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    // Free memory
    free(arr);
    return 0;
}

Output:

arr[0] = 1  
arr[1] = 2  
arr[2] = 3  
arr[3] = 4  
arr[4] = 5

Key Notes:

  1. Data Retention: When increasing memory, the original data in the allocated block remains intact.
  2. Pointer Reassignment: Always reassign the returned pointer from realloc() to avoid memory leaks.

Best Practices for Using realloc()

  • Always Check the Return Value:
    Ensure realloc() doesn’t return NULL, as this indicates reallocation failure.
  • Avoid Memory Leaks:
    Assign the result of realloc() to a temporary pointer and validate it before overwriting the original pointer. 
int *temp = realloc(arr, new_size);
if (temp != NULL) {
    arr = temp;
} else {
    // Handle reallocation failure
}
  • Free Unused Memory:
    Release dynamically allocated memory using free() when it is no longer needed.
  • Be Aware of Data Loss:
    Reducing the memory size with realloc() might lead to data loss if the truncated portion contains meaningful data.

Common Use Cases of realloc()

  1. Dynamic Arrays: Resize arrays to store more or fewer elements based on user input or program logic.
  2. Buffer Management: Resize buffers for dynamic file or network data handling.
  3. Dynamic Data Structures: Modify the size of structures like linked lists, stacks, and queues.

Common Errors When Using realloc()

  1. Dereferencing Freed Memory: Ensure you do not use the old pointer after calling realloc().
  2. Memory Leaks: Failing to free memory after using realloc().
  3. Undefined Behavior: Passing an uninitialized or NULL pointer to realloc() can lead to undefined behavior.

Real-Life Example: Dynamic User Input

Here’s an example where realloc() is used to dynamically resize a buffer for storing user input:

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

int main() {
    char *buffer = malloc(10 * sizeof(char));
    if (buffer == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    int size = 10;
    int len = 0;
    printf("Enter text (type 'exit' to quit): ");

    while (1) {
        char ch = getchar();

        // Resize buffer if needed
        if (len >= size - 1) {
            size += 10;
            char *temp = realloc(buffer, size);
            if (temp == NULL) {
                printf("Memory reallocation failed!\n");
                free(buffer);
                return 1;
            }
            buffer = temp;
        }

        if (ch == '\n') {
            buffer[len] = '\0';
            if (strcmp(buffer, "exit") == 0) {
                break;
            }
            printf("You entered: %s\n", buffer);
            len = 0;
        } else {
            buffer[len++] = ch;
        }
    }

    free(buffer);
    return 0;
}

Conclusion

The realloc() function is a powerful tool for managing memory in C. By resizing memory blocks dynamically, you can make your programs more efficient and flexible. However, using realloc() requires careful handling to avoid memory leaks and errors.

Leave a Comment