C Dynamic Memory Allocation

Dynamic memory allocation means allocating memory for program into run time. The run time allocation for memory is done during the program execution. In dynamic memory allocation, the heap data structure is used for allocating memory. Memory is reusable when we use dynamic memory allocation. More efficient way to allocate memory dynamically than static memory allocation. We can easily free the allocate space in case of dynamic memory allocation.
Four method manages the dynamic memory allocation in C programming language:

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

Note: Library uses for memory management function is <stdlib.h>

Malloc() Method

Malloc stands for memory allocation. Malloc() allocates memory into single block with fixed or specific size. It assigns the value into pointer type variable. Malloc() method initialize with garbage in all the value.

ptr = (castType*) malloc(size);

ptr = (int*) malloc(400 * sizeof(int));

The sizeof() operator returns the data type Size. In the above example, int size is 4 bytes, the statement will allocate 1600 (400*4) bytes of memory. The first byte of memory address assign into pointer ptr.

ptr = 1600 bytes(Single blocks)

ptr = (float*) malloc(100 * sizeof(float));

In the above example, float size is 4 bytes, the statement will allocate 400 (100*4) bytes of memory.The first byte of memory address assign into pointer ptr.

ptr = 400 bytes(single blocks)

Note: The NULL pointer returns when memory allocation fail, insufficient or memory cannot be allocated.

Here is a program example of dynamic memory allocation using malloc() method.

#include <stdio.h>
#include <stdlib.h>
int main() {
  int *ptr
  int a, b;
  a = 10;
  printf("Enter number : %d\n", a);
  // Dynamically allocate memory using malloc()
  ptr = (int*)malloc(a * sizeof(int));
  if (ptr == NULL) {
    printf ("Memory is not allocated.\n");
    exit(0);
  }
  else {
    printf ("Successfully allocated memory using malloc.\n");
    for(b = 0; b < a; ++b) {
      ptr[b] = b + 1;
    }
    printf("The elements of the array are: ");
    for(b = 0; b < a; ++b) {
      printf ("%d", ptr[b]);
    }
  }
  return 0;
}

Enter number : 10
Successfully allocated memory using malloc.
The elements of the array are: 1 2 3 4 5 6 7 8 9 10

Calloc() Method

Calloc stands for contiguous allocation. Calloc() allocates memory into multiple block of specific data type. It assigns the value into pointer type variable. Calloc() method initialize with zero(0) in all the value.

ptr = (cast-type*)calloc(n, data_type_size);

ptr = (int*) calloc(5 , sizeof(int));

The sizeof() operator returns the data type Size. In the above example, int size is 4 bytes, the statement will allocate 5 blocks and each block contains 4 bytes of memory. The first byte of memory address assign into pointer ptr.

The representation of ptr in example 1:

ptr = (float*) calloc(7 * sizeof(float));

In the above example, float size is 4 bytes, the statement will allocate 7 blocks and each block size is 4 bytes of memory. The first byte of memory address assign into pointer ptr.

The representation of ptr in example 2:

Here is a program example of dynamic memory allocation using calloc() method.

#include <stdio.h>
#include <stdlib.h>
int main() {
  int *ptr
  int a, b;
  a = 10;
  printf("Enter number : %d\n", a);
  // Dynamically allocate memory using calloc()
  ptr = (int*)calloc(a, sizeof(int));
  if (ptr == NULL) {
    printf ("Memory is not allocated.\n");
    exit(0);
  }
  else {
    printf ("Successfully allocated memory using malloc.\n");
    for(b = 0; b < a; ++b) {
      ptr[b] = b + 1;
    }
    printf("The elements of the array are: ");
    for(b = 0; b < a; ++b) {
      printf ("%d", ptr[b]);
    }
  }
  return 0;
}

Enter number : 10
Successfully allocated memory using calloc.
The elements of the array are: 1 2 3 4 5 6 7 8 9 10

Note: Realloc() and Free() methods are described in the next tutorial.