The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Calloc and Realloc

Next ►
►

In this section, we will delve into two essential functions for dynamic memory allocation in C: calloc and realloc. These functions provide more flexibility and control over memory management compared to malloc.

  1. Calloc

What is calloc?

calloc stands for "contiguous allocation." It is used to allocate memory for an array of elements and initializes all bytes to zero.

Syntax

void* calloc(size_t num_elements, size_t element_size);
  • num_elements: Number of elements to allocate.
  • element_size: Size of each element.

Example

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

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

    // Allocate memory for an array of 5 integers
    arr = (int*) calloc(n, sizeof(int));

    // Check if memory allocation was successful
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

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

    // Free the allocated memory
    free(arr);

    return 0;
}

Explanation

  1. Memory Allocation: calloc(n, sizeof(int)) allocates memory for an array of 5 integers and initializes all elements to zero.
  2. Null Check: Always check if the memory allocation was successful.
  3. Initialization: The array elements are automatically initialized to zero.
  4. Free Memory: Use free to deallocate the memory once it is no longer needed.

  1. Realloc

What is realloc?

realloc is used to resize a previously allocated memory block. It can either expand or shrink the memory block.

Syntax

void* realloc(void* ptr, size_t new_size);
  • ptr: Pointer to the previously allocated memory block.
  • new_size: New size of the memory block.

Example

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

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

    // Allocate memory for an array of 5 integers
    arr = (int*) malloc(n * sizeof(int));

    // Check if memory allocation was successful
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // Initialize the array
    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;
    }

    // Resize the array to hold 10 integers
    arr = (int*) realloc(arr, 10 * sizeof(int));

    // Check if memory reallocation was successful
    if (arr == NULL) {
        printf("Memory reallocation failed\n");
        return 1;
    }

    // Initialize the new elements
    for (int i = n; i < 10; i++) {
        arr[i] = i + 1;
    }

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

    // Free the allocated memory
    free(arr);

    return 0;
}

Explanation

  1. Initial Allocation: malloc(n * sizeof(int)) allocates memory for an array of 5 integers.
  2. Initialization: The array is initialized with values from 1 to 5.
  3. Resizing: realloc(arr, 10 * sizeof(int)) resizes the array to hold 10 integers.
  4. Null Check: Always check if the memory reallocation was successful.
  5. New Elements Initialization: The new elements are initialized with values from 6 to 10.
  6. Free Memory: Use free to deallocate the memory once it is no longer needed.

Practical Exercises

Exercise 1: Using calloc

Task: Write a program that uses calloc to allocate memory for an array of 10 floats, initializes them to zero, and prints the array.

Solution:

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

int main() {
    float *arr;
    int n = 10;

    // Allocate memory for an array of 10 floats
    arr = (float*) calloc(n, sizeof(float));

    // Check if memory allocation was successful
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // Print the initialized array
    for (int i = 0; i < n; i++) {
        printf("%.2f ", arr[i]);
    }

    // Free the allocated memory
    free(arr);

    return 0;
}

Exercise 2: Using realloc

Task: Write a program that uses malloc to allocate memory for an array of 5 integers, initializes them, then uses realloc to resize the array to 8 integers, and initializes the new elements.

Solution:

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

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

    // Allocate memory for an array of 5 integers
    arr = (int*) malloc(n * sizeof(int));

    // Check if memory allocation was successful
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // Initialize the array
    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;
    }

    // Resize the array to hold 8 integers
    arr = (int*) realloc(arr, 8 * sizeof(int));

    // Check if memory reallocation was successful
    if (arr == NULL) {
        printf("Memory reallocation failed\n");
        return 1;
    }

    // Initialize the new elements
    for (int i = n; i < 8; i++) {
        arr[i] = i + 1;
    }

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

    // Free the allocated memory
    free(arr);

    return 0;
}

Common Mistakes and Tips

  1. Null Check: Always check if the memory allocation or reallocation was successful by checking if the returned pointer is NULL.
  2. Memory Leaks: Ensure that you free any dynamically allocated memory using free to avoid memory leaks.
  3. Initialization: Remember that calloc initializes the allocated memory to zero, while malloc does not.
  4. Reallocation: When using realloc, if the new size is smaller, the data beyond the new size is lost. If the new size is larger, the new memory is uninitialized.

Conclusion

In this section, we covered the calloc and realloc functions for dynamic memory allocation in C. We learned how to use these functions to allocate, initialize, and resize memory blocks. Understanding these functions is crucial for efficient memory management in C programming. In the next section, we will explore file handling in C, which is essential for reading from and writing to files.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved