What is dynamic memory allocation in c programming language?

Dynamic memory allocation
Dynamic memory allocation


Dynamic memory allocation in c programming language can be defined as a procedure in which the size of data structure (like array) is changed during the runtime.

Since C is a structured language. It has some fixed rules for programming. One of the include changing the size of an array stored at continuous memory location.

C defined under <stdlib.h> header file to facilitated dynamic memory allocation in c programming.

Type of dynamic memory allocation :

  1. Malloc()
  2. Calloc()
  3. Realoc()
  4. Free()

Malloc() :

“malloc” or “memory allocation” method in c is used to dynamically allocate a single large block of memory with the specified size.

It returns null if memory is not sufficient and allocates single block of required continuous memory allocation. 

Syntax :

Ptr=(int*) malloc(n*size of (int));

Example :

ptr=(int*) malloc (100*size of (int)); //integer data type.
ptr=(float*) malloc (5*size of (float)); //float data type.
ptr=(char*) malloc (‘a’*size of (char)); //character data type.

Example with program :

#include <stdio.h>
#include<stdlib.h>
int main(){
int n,i;
int *ptr;
int a[5];
printf("enter number of element\n");
scanf("%d",&n);
ptr=(int*)malloc(n* sizeof(int));
if(ptr==0){
printf("memory not allocated\n");
}
else {
printf("memory successfully allocated\n");
}
return 0;
}

Program example:

#include <stdio.h>
#include<stdlib.h>
int main() {
int n,i;
int *ptr;
int a[5];
printf("enter number of element\n");
scanf("%d",&n);
ptr=(int*) malloc (n* sizeof (int));
if(ptr==0){
printf("memory not allocated");
}
else{
printf("memory successfully allocated\n");
}
for(i=0;i<n;i++){
ptr[i]=i+1;
}
printf("the element of the array:\n");
for(i=0;i<n;i++){
printf("%d",ptr[i]);
}
return 0;
}

Calloc() :

“calloc”or “continuous memory allocation” method in c is use to dynamically allocate the specific  number of blocks of memory of the specific type it initializes each block with a default value ‘0’.

It has two parameters or argument as compared to malloc. The continuous memory allocated to use in a calloc() function.

Continuous allocation may be defined as a collection of similar data type and step by step representation in memory allocation. It is not using the single large number of blocks of memory.

It returns null if memory is sufficient in a dynamic memory allocation.

Syntax :

Ptr=(int*) calloc (n, sizeof (int));

Example :

#include <stdio.h>
int main() {
int n,i;
int *ptr;
int a[5];
printf("enter number of element\n");
scanf("%d",&n);
ptr=(int*) calloc (n,sizeof(int));
if(ptr==0){
printf("memory not allocated\n");
}
else
{
printf("memory successfully allocated\n");
}
return 0;
}

Program example: 


#include <stdio.h>
#include<stdlib.h>
int main() {
int n,i;
int *ptr;
int a[5];
printf("enter number of element\n");
scanf("%d",&n);
ptr=(int*) calloc (n,sizeof (int));
if(ptr==0){
printf("memory not allocated");
}
else{
printf("memory successfully allocated\n");
}
for(i=0;i<n;i++){
ptr[i]=i+1;
}
printf("the element of the array:\n");
for(i=0;i<n;i++){
printf("%d",ptr[i]);
}
return 0;
}

Realloc() :

“realloc” or “re-allocation” method in c is used to dynamically change the memory allocation of a previously allocated memory.

Realloc can be used to dynamically re-allocation memory. re-allocation of memory maintains the already present value and new blocks will be initialized with default garbage value.

Syntax :

Ptr =realloc(ptr, n*size of (int));

Example :

Ptr=realloc(ptr,100*sizeof (int));

  Program example:    

#include <stdio.h>
#include<stdlib.h>
int main() {
int n,i;
int *ptr;
printf("enter number of element\n");
scanf("%d",&n);
ptr=(int*) calloc (n, sizeof(int));//using the continuous memory allocation
if(ptr==0){
printf("memory not allocated");
}
else{
printf("memory successful allocated\n");
for(i=0;i<n;i++){
ptr[i]=i+1;
}
for(i=0;i<n;i++){
printf("%d\n",ptr[i]);
}
n=6;
printf("enter the new size of the array:%d\n",n);
ptr= realloc(ptr, n*sizeof(int));//using the re-allocated memory
printf("memory successfull re-allocated in using realloc\n");
for(i=5;i<n;i++){
ptr[i]=i+1;
}
printf("the element of the array :");
for(i=0;i<n;i++){
printf("%d\n",ptr[i]);
}
free(ptr);
}
return 0;
}

Free() method :

“free” method in c is used to dynamically de-allocated the memory. the memory allocated using function malloc() and calloc() is not de-allocated on their own.

Hence the free() method is used.

Syntax: 

free(ptr);

Program example :

#include <stdio.h>
#include<stdlib.h>
int main() {
int n,i;
int *ptr1,*ptr2;
printf("enter number of element");
scanf("%d",&n);
ptr1=(int*) malloc (n* sizeof(int));
ptr2=(int*) calloc (n, sizeof(int));
if(ptr1==0 && ptr2==0){
printf("memory not allocated\n");
}
else{
printf("memory successfull allocated using by malloc()\n");
free(ptr1);// memory free ptr1 funcation
printf("malloc memory successfully free.\n");
printf("memory successfully allocated using by calloc().\n");
free(ptr2);//memory free ptr2 funcation
printf("calloc memory successfully free.\n");
}
return 0;
}

Output :

enter number of elements 5 
memory successfull allocated using by malloc() 
malloc memory successfully free. 
memory successfully allocated using by calloc().
calloc memory successfully free.