C malloc() Function

The malloc() function in C is a standard library function that allocates a block of memory of a specified size. It is part of the C standard library (stdlib.h). This function is commonly used for dynamic memory allocation, allowing programs to request memory at runtime.

Table of Contents

1. Introduction
2. malloc() Function Syntax
3. Understanding malloc() Function
4. Examples
   • Allocating a Single Memory Block
   • Allocating an Array
5. Real-World Use Case
6. Conclusion

Introduction

The malloc() function is useful for allocating memory dynamically, which means the memory is allocated at runtime rather than at compile time. This is essential for scenarios where the amount of memory required is not known in advance, such as in dynamic data structures.

malloc() Function Syntax

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

void *malloc(size_t size); 

Parameters:

• size: The number of bytes to allocate.

Returns:

• The function returns a pointer to the allocated memory. If the allocation fails, it returns NULL.

Understanding malloc() Function

The malloc() function allocates a contiguous block of memory of the specified size and returns a pointer to the beginning of this block. The contents of the allocated memory are not initialized and may contain garbage values. It is important to check the returned pointer to ensure that the memory allocation was successful before using the allocated memory.

Examples

Allocating a Single Memory Block

To demonstrate how to use malloc() to allocate 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); // Free the allocated memory free(ptr); return 0; } 

Output:

Allocated integer value: 42 

Allocating an Array

This example shows how to use malloc() to allocate memory for an array of integers.

Example

#include <stdio.h> #include <stdlib.h> int main() { int *array; int num_elements = 5; int i; // Allocate memory for an array of integers array = (int *)malloc(num_elements * sizeof(int)); if (array == NULL) { printf("Memory allocation failed.\n"); return 1; } // Initialize and print the array for (i = 0; i < num_elements; i++) { array[i] = i * 2; printf("array[%d] = %d\n", i, array[i]); } // Free the allocated memory free(array); return 0; } 

Output:

array[0] = 0 array[1] = 2 array[2] = 4 array[3] = 6 array[4] = 8 

Real-World Use Case

Dynamic Memory Allocation for Data Structures

In real-world applications, dynamic data structures such as linked lists, trees, and graphs often require dynamic memory allocation. The malloc() function is used to allocate memory for new elements as needed.

Example: Allocating Memory for a Linked List Node

#include <stdio.h> #include <stdlib.h> // Define a node structure struct Node { int data; struct Node *next; }; int main() { // Allocate memory for a new node struct Node *node = (struct Node *)malloc(sizeof(struct Node)); if (node == NULL) { printf("Memory allocation failed.\n"); return 1; } // Initialize the node node->data = 10; node->next = NULL; // Print the node's data printf("Node data: %d\n", node->data); // Free the allocated memory free(node); return 0; } 

Output:

Node data: 10 

Conclusion

The malloc() function is used for dynamic memory allocation in C. By understanding and using this function correctly, you can allocate memory at runtime, enabling the implementation of dynamic data structures and efficient memory management in your programs. Always ensure to check for successful memory allocation and to free the allocated memory when it is no longer needed to prevent memory leaks.