C Program to Allocate Memory for an Array Using calloc()

Introduction

In C programming, dynamic memory allocation allows you to allocate memory at runtime. The calloc() function is used to allocate memory for an array of elements and initializes all bytes to zero. Unlike malloc(), which allocates a single block of memory, calloc() allocates multiple blocks of memory, each of the same size.

Example:

• Input: Number of elements to store in an array
• Output: Memory allocated and elements initialized to zero

Problem Statement

Create a C program that:

• Prompts the user to enter the number of elements they want to store.
• Allocates memory dynamically for an array using calloc().
• Displays the elements of the array (which will be initialized to zero).

Solution Steps

1. Include the Standard Libraries: Use #include <stdio.h> for standard input-output functions and #include <stdlib.h> for dynamic memory allocation functions.
2. Prompt the User for the Number of Elements: Ask the user how many elements they want to store in the array.
3. Allocate Memory Dynamically Using calloc(): Use calloc() to allocate memory for the number of elements specified by the user.
4. Check if Memory Allocation was Successful: Ensure the pointer returned by calloc() is not NULL.
5. Display the Array Elements: Use a loop to display the elements of the array (which will be zero).
6. Free the Allocated Memory: Use free() to deallocate the memory once it is no longer needed.

C Program to Allocate Memory for an Array Using calloc()

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

int main() {
    int *ptr;
    int n, i;

    // Step 2: Prompt the user for the number of elements
    printf("Enter the number of elements: ");
    scanf("%d", &n);

    // Step 3: Allocate memory dynamically using calloc()
    ptr = (int*)calloc(n, sizeof(int));

    // Step 4: Check if memory allocation was successful
    if (ptr == NULL) {
        printf("Memory allocation failed.\n");
        return 1;  // Exit the program if memory allocation fails
    }

    // Step 5: Display the array elements (initialized to zero)
    printf("The array elements are initialized to zero:\n");
    for (i = 0; i < n; i++) {
        printf("%d ", ptr[i]);
    }
    printf("\n");

    // Step 6: Free the allocated memory
    free(ptr);

    return 0;  // Return 0 to indicate successful execution
}

Explanation

Step 2: Prompt the User for the Number of Elements

• The program asks the user to input the number of elements they want to store, which is then stored in the variable n.

Step 3: Allocate Memory Dynamically Using calloc()

• The calloc() function is used to allocate memory for n elements. The size of each element is sizeof(int), where sizeof(int) is the size of an integer in bytes.
• The pointer ptr is used to point to the allocated memory. The memory allocated by calloc() is initialized to zero.

Step 4: Check if Memory Allocation was Successful

• The program checks if ptr is NULL. If it is, it means the memory allocation failed, and the program displays an error message and exits.

Step 5: Display the Array Elements

• A for loop is used to display the elements of the array. Since calloc() initializes the memory to zero, all the elements will be zero.

Step 6: Free the Allocated Memory

• The free() function is called to deallocate the memory allocated by calloc(). This is important to prevent memory leaks.

Return 0

• The return 0; statement indicates that the program executed successfully.

Output Example

Example Output:

Enter the number of elements: 5
The array elements are initialized to zero:
0 0 0 0 0

Conclusion

This C program demonstrates how to allocate memory dynamically for an array using calloc(). It covers basic concepts such as dynamic memory allocation, pointer manipulation, and memory deallocation, making it a useful example for beginners learning C programming.