Malloc in C

This section will discuss the allocation of the Dynamic memory using the malloc in the C programming language. The malloc is a predefined library function that stands for memory allocation. A malloc is used to allocate a specified size of memory block at the run time of a program. It means it creates a dynamic memory allocation at the run time when the user/programmer does not know the amount of memory space is needed in the program.

Therefore, it inputs the memory size (in bytes) at the run time to reserve a contiguous memory block that returns a pointer of type void, which is cast into a pointer of any form. The dynamic memory is created using the malloc does not initialize the memory at execution time, and hence the memory block contains some default garbage value. The malloc function is defined inside the stdlib.h header file. So, we need to use <stdlib.h> header file while using the malloc function in our program.

Syntax

In the above syntax, the byte_size is an argument that specifies the size of the memory block (in byte), which is passed into the malloc function to reserve the contiguous memory. A malloc() function returns a type void pointer that can be cast into pointers of any defined form.

Program to check memory is created using the malloc function

Let's consider an example to check memory is created using the malloc function in the C programming language.

Program1.c

#include <stdio.h>
#include <stdlib.h> // use stdlib.h header file to malloc() function
int main ()
{
	int *pt; // declare a pointer of type int
	// use malloc() function to define the size of block in bytes
	pt = malloc (sizeof(int));
	
	// use if condition that defines ptr is not equal to null
	if (pt != NULL)
	{
		printf (" Memory is created using the malloc() function ");
	}
	else
	printf (" memory is not created ");
	return 0;	
} 

Output

Memory is created using the malloc() function

In the above program, we create an integer type dynamic memory using the malloc() function that returns an integer pointer to point to the base address. And if the statement checks whether the ptr is equal to NULL pointer and if the statement is true, it means the memory is not created. Else the memory is successfully created through the malloc() function.

Program to create a dynamic memory using the malloc() function

Let's consider an example of taking the size as an input from the user and then entering data at the run time using the malloc () function in the C programming language.

Program2.c

#include <stdio.h>
#include <stdlib.h> 
int main ()
{
	// declare the local variables
	int *ptr, size, i;
	
	printf (" Enter the allocated size of memory ");
	scanf (" %d", &size); // get the size of a memory	
	// use malloc() function to define the size of block in bytes
	ptr = malloc (size * sizeof(int));	
	// use if condition that defines ptr is not equal to null
	if (ptr != NULL)
	{
		// get an input from the user and print it
		printf (" Enter numbers from the user: ");		
		for ( i = 0; i < size; i++)
		{
			scanf (" %d", ptr + i); // stores the numbers from base address of memory
		}		
		printf (" Numbers are stores in contiguous memory: \n ");		
		for ( i = 0; i < size; i++)
		{
			printf (" \n The number is: %d", *(ptr + i)); // here *(ptr + i) is same as ptr[i]
		}
		printf (" \n Memory is created using the malloc() function ");
		return 0;
	}
	else
	printf (" memory is not created ");
	return 0;
}

Output

Enter the allocated size of memory 10
 Enter numbers from the user: 25
40
20
13
56
78
67
24
10
7
 Numbers are stores in contiguous memory:
 The number is: 25
 The number is: 40
 The number is: 20
 The number is: 13
 The number is: 56
 The number is: 78
 The number is: 67
 The number is: 24
 The number is: 10
 The number is: 7
 Memory is created using the malloc() function

Release memory space using the free() function

A free() function releases the dynamic memory allocation created through the malloc() function. The dynamic memory could not free the occupied memory itself, and the existing space remains even program end. Therefore, we need to free the reserved memory so that other programs can reuse it.

Syntax

In the above syntax, we pass ptr inside the free() function that acts as the reference or base address of the dynamic memory to points to the memory block.

Program3.c

#include <stdio.h>
#include <stdlib.h>
void main()
{
	int num, i, sum = 0;
	int *ptr, *p;
	printf (" The number of elements to be entered: \n ");
	scanf (" %d", &num); // define the no. of element to be entered	
	// use malloc() function to define the size of memory block
	ptr = (int *) malloc (num);
	p = ptr; // store the base address of ptr in p	
	// validate the string is full or not
	if (ptr == NULL)
	{
		printf (" Memory is not allocated ");
		exit(0); // exit from program
	}
	else
	{
		printf (" Memory is created using the malloc() function ");
	}
	printf ("\n Enter the elements in allocated space: ");	
	for (i = 1; i <= num; i++)
	{
		scanf (" %d", ptr);
		sum = sum + *ptr;
		ptr++;
	}	
	// print the entered number
	printf (" Elements are: ");
	for (i = 1; i <= num; i++)
	{
		printf (" \n %d", *p);
		p++;
	}	
	printf (" \n The addition of stored elements is: %d ", sum);
	free (ptr); // use free() function to release the occupy space using malloc() function
	getch();	
}

Output

The number of elements to be entered:
10
 Memory is created using the malloc() function
 Enter the elements in allocated space: 45
12
67
89
34
56
25
25
67
34
 Elements are:
 45
 12
 67
 89
 34
 56
 25
 25
 67
 34
 The addition of stored elements is: 454

Next TopicTable Program in C

← prev next →