Memory Allocation in C: malloc(), calloc(), realloc(), and free

Understanding Memory Allocation in C:
malloc(), calloc(), realloc(), and free()

Table of Contents

1. Introduction to Memory Allocation


2. malloc() Function


3. calloc() Function


4. realloc() Function


5. free() Function


6. Example: Dynamic Array

Introduction to Memory Allocation

In C programming, memory allocation is a crucial concept that allows you to allocate and manage memory dynamically during runtime. The malloc(), calloc(), realloc(), and free() functions are used for this purpose.

malloc() Function

The malloc() function (Memory ALLOCation) is used to allocate a specified amount of memory and returns a pointer to the first byte of the allocated memory block.

Function Signature	Explanation
void* malloc(size_t size);	Allocates size bytes of memory and returns a pointer to the allocated memory block.

Example:

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

int main() {
    int *ptr;
    ptr = (int *)malloc(5 * sizeof(int)); // Allocating memory for 5 integers

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

    // Use the allocated memory

    free(ptr); // Freeing the allocated memory

    return 0;
}

calloc() Function

The calloc() function (Contiguous ALLOCation) is used to allocate memory for an array of elements, initializing them to zero, and returns a pointer to the allocated memory block.

Function Signature	Explanation
void* calloc(size_t num_elements, size_t element_size);	Allocates memory for an array of num_elements elements, each of size element_size bytes, and initializes them to zero.

Example:

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

int main() {
    int *ptr;
    int num_elements = 5;
    ptr = (int *)calloc(num_elements, sizeof(int)); // Allocating memory for 5 integers

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

    // Use the allocated memory

    free(ptr); // Freeing the allocated memory

    return 0;
}

realloc() Function

The realloc() function (Re-ALLOCation) is used to resize an existing memory block, and returns a pointer to the new memory block. It can also be used to allocate memory if the pointer is initially NULL.

Function Signature	Explanation
void* realloc(void* ptr, size_t new_size);	Resizes the memory block pointed to by ptr to new_size bytes and returns a pointer to the new memory block.

Example:

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

int main() {
    int *ptr;
    ptr = (int *)malloc(5 * sizeof(int)); // Allocating memory for 5 integers

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

    // Resize the memory block to hold 10 integers
    ptr = (int *)realloc(ptr, 10 * sizeof(int));

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

    // Use the resized memory

    free(ptr); // Freeing the allocated memory

    return 0;
}

free() Function

The free() function is used to deallocate or release the memory previously allocated using malloc(), calloc(), or realloc().

Function Signature	Explanation
void free(void* ptr);	Deallocates the memory block pointed to by ptr, making it available for further use.

Example: Dynamic Array

Let's create a simple program that demonstrates the use of malloc() to create a dynamic array and free() to release the memory.

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

int main() {
    int n, *arr;

    printf("Enter the size of the array: ");
    scanf("%d", &n);

    arr = (int *)malloc(n * sizeof(int)); // Allocate memory for the array

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

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

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

    free(arr); // Free the allocated memory

    return 0;
}

Conclusion

The malloc(), calloc(), realloc(), and free() functions are essential tools for managing memory dynamically in C. They allow you to allocate and release memory blocks as needed, enabling more efficient use of resources in your programs. By understanding and using these functions, you can create flexible and responsive applications that make the most of available memory.

Thank you for reading! We hope this post has provided you with a clear understanding of memory allocation in C.