In C, the free function is used to deallocate memory that has been previously allocated using functions like malloc, calloc, or realloc. The main purpose of free is to release the memory back to the system so that it can be reused by the program or other applications, preventing memory leaks.

1. free Function Overview

• Declared in the <stdlib.h> header file.
• Frees the dynamically allocated memory that was allocated using malloc, calloc, or realloc.
• After freeing memory, the pointer to the memory block becomes invalid, meaning that accessing it leads to undefined behavior.

2. Syntax

void free(void* ptr);

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

3. How free Works

• When you allocate memory dynamically using malloc, calloc, or realloc, the memory remains allocated until you explicitly release it using free.
• Failure to use free leads to memory leaks, where the memory is no longer used but still reserved, potentially exhausting system resources over time.

4. Usage Example

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

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

    // Allocate memory for 5 integers
    arr = (int *)malloc(n * sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // Assign values to the allocated memory
    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;
    }

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

    // Free the allocated memory
    free(arr);

    // Attempt to use freed memory is dangerous and leads to undefined behavior
    // arr[0] = 10; // DO NOT do this, as it leads to undefined behavior

    return 0;
}

Explanation:

1. Memory Allocation: Allocate memory for an array of integers using malloc.
2. Assign Values and Print: Values are assigned to the allocated array.
3. Free Memory: The allocated memory is freed using free(arr).
4. Accessing Freed Memory: Once free is called, the pointer arr becomes invalid, and using it (e.g., arr[0] = 10) leads to undefined behavior.

5. Important Considerations

1. Nullifying the Pointer:

   • After freeing memory, it’s a good practice to set the pointer to NULL to avoid accidentally accessing freed memory.

   free(arr);
   arr = NULL;
   

   • Setting the pointer to NULL ensures that subsequent attempts to use it will be easily identifiable as invalid.

2. Multiple free Calls:

   • Calling free on a pointer more than once (a double free) can cause program crashes or other unpredictable behavior.

   free(arr);
   free(arr);  // DO NOT do this
   

3. Freeing NULL:

   • If the pointer passed to free is NULL, free does nothing, which prevents issues when trying to free an unallocated pointer.

   int *ptr = NULL;
   free(ptr);  // Safe, does nothing
   

4. Undefined Behavior:

   • Using a pointer after freeing its memory results in undefined behavior. This includes both reading and writing to that memory.

   free(arr);
   printf("%d\n", arr[0]);  // Undefined behavior
   

5. Memory Leak:

   • Failing to call free after allocating memory leads to memory leaks. A memory leak occurs when memory that is no longer needed is not released, and it can reduce available memory over time, causing performance issues or program crashes.

6. Example: Using free with Structures

You can also use free to deallocate memory that was allocated for a structure.

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

// Define a structure
struct Person {
    char name[50];
    int age;
};

int main() {
    struct Person *personPtr;

    // Allocate memory for one Person structure
    personPtr = (struct Person *)malloc(sizeof(struct Person));
    if (personPtr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // Assign values to the structure members
    personPtr->age = 30;
    snprintf(personPtr->name, 50, "John Doe");

    // Print the values
    printf("Name: %s, Age: %d\n", personPtr->name, personPtr->age);

    // Free the allocated memory
    free(personPtr);

    // Setting pointer to NULL to avoid accidental access
    personPtr = NULL;

    return 0;
}

Explanation:

• Allocate memory for a Person structure.
• Assign values and print them.
• Free the allocated memory and set the pointer to NULL to ensure it is not accidentally used again.

7. Freeing Dynamically Allocated Arrays

When you use calloc or malloc to allocate memory for an array, you need to free it in the same way. You only need one free call for the entire block of memory.

int *arr = (int *)malloc(10 * sizeof(int));
if (arr == NULL) {
    // Handle allocation failure
}
free(arr);  // Frees all 10 elements

Summary

• free is used to release memory that was previously allocated dynamically.
• Always free memory that you allocate to prevent memory leaks.
• Avoid accessing or modifying a pointer after it has been freed, as this leads to undefined behavior.
• Set the pointer to NULL after calling free to prevent accidental access.
• Double freeing the same pointer should be avoided, as it can lead to crashes or security vulnerabilities.

Using free correctly is crucial for managing memory in C, especially in long-running applications or those with heavy memory requirements, ensuring the program remains stable and efficient.