C free() Function | Deallocate Dynamically Allocated Memory

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Introduction

The free() function in C is a standard library function that deallocates a memory block previously allocated by malloc(), calloc(), or realloc(). It is part of the C standard library (stdlib.h). This function is crucial for preventing memory leaks by releasing memory that is no longer needed.

free() Function Syntax

The syntax for the free() function is as follows:

void free(void *ptr);

Parameters:

ptr: A pointer to the memory block to be deallocated. If ptr is NULL, no operation is performed.

Returns:

The free() function does not return a value.

Understanding free() Function

The free() function releases the memory block pointed to by ptr back to the system, making it available for future allocations. It is important to ensure that only dynamically allocated memory is freed, and each allocated block is freed exactly once to avoid undefined behavior.

Examples

Deallocating a Single Memory Block

To demonstrate how to use free() to deallocate a single memory block, we will write a simple program.

Example

#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;
    }

    // Use the allocated memory
    *ptr = 42;
    printf("Allocated integer value: %d\n", *ptr);

    // Deallocate the memory
    free(ptr);

    return 0;
}

Output:

Allocated integer value: 42

Deallocating a 2D Array

This example shows how to use free() to deallocate a dynamically allocated 2D array.

Example

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

int main() {
    int rows = 3, cols = 4;
    int i;
    int **matrix;

    // Allocate memory for rows
    matrix = (int **)malloc(rows * sizeof(int *));
    if (matrix == NULL) {
        printf("Memory allocation failed.\n");
        return 1;
    }

    // Allocate memory for columns
    for (i = 0; i < rows; i++) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
        if (matrix[i] == NULL) {
            printf("Memory allocation failed.\n");
            return 1;
        }
    }

    // Use the allocated memory (initialize the matrix)
    for (i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = i + j;
        }
    }

    // Print the matrix
    for (i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("matrix[%d][%d] = %d\n", i, j, matrix[i][j]);
        }
    }

    // Deallocate the memory
    for (i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);

    return 0;
}

Output:

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

Real-World Use Case

Managing Memory for Dynamic Data Structures

In real-world applications, dynamic data structures such as linked lists, trees, and graphs often require dynamic memory allocation. The free() function is used to deallocate memory when these structures are no longer needed, ensuring efficient memory usage and preventing memory leaks.

Example: Deallocating a Linked List

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

// Define a node structure
struct Node {
    int data;
    struct Node *next;
};

// Function to create a new node
struct Node* createNode(int data) {
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    if (newNode == NULL) {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// Function to free the linked list
void freeList(struct Node *head) {
    struct Node *temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp);
    }
}

int main() {
    // Create a linked list with three nodes
    struct Node *head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);

    // Print the linked list
    struct Node *temp = head;
    while (temp != NULL) {
        printf("Node data: %d\n", temp->data);
        temp = temp->next;
    }

    // Free the linked list
    freeList(head);

    return 0;
}

Output:

Node data: 1
Node data: 2
Node data: 3

Conclusion

The free() function is a crucial tool for managing dynamically allocated memory in C. By understanding and using this function correctly, you can prevent memory leaks and ensure efficient memory usage in your programs.

Always ensure that only dynamically allocated memory is freed, and each allocated block is freed exactly once to avoid undefined behavior.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide

Java Guides

Search This Blog