Unit-9 Dynamic Memory

Allocation

1
Dynamic Memory Allocation (DMA)
 Since C is a structured language, it has some fixed rules for
programming.
 One of it includes changing the size of an array. An array is
collection of items stored at continuous memory locations.

 As it can be seen that the length (size) of the array above made is
9. But what if there is a requirement to change this length (size).
For Example,
Dynamic Memory Allocation (DMA)
 If there is a situation where only 5 elements are needed to be
entered in this array. In this case, the remaining 4 indices are just
wasting memory in this array. So there is a requirement to lessen
the length (size) of the array from 9 to 5.
 Take another situation. In this, there is an array of 9 elements with
all 9 indices filled. But there is a need to enter 3 more elements in
this array. In this case 3 indices more are required. So the length
(size) of the array needs to be changed from 9 to 12.

 This procedure is referred to as Dynamic Memory Allocation in C.

Dynamic Memory Allocation (DMA)
 Therefore, C Dynamic Memory Allocation can be defined as a
procedure in which the size of a data structure (like Array) is
changed during the runtime.
 C provides some functions to achieve these tasks. There are 4
library functions provided by C defined under <stdlib.h> header
file to facilitate dynamic memory allocation in C programming.
They are:
• malloc()
• calloc()
• free()
• realloc()
Dynamic Memory Allocation (DMA)
 If memory is allocated at runtime (during execution of program)
then it is called dynamic memory.
 It allocates memory from heap (heap: it is an empty area in
memory)
 Memory can be accessed only through a pointer.

When DMA is needed?

 It is used when number of variables are not known in advance or
large in size.
 Memory can be allocated at any time and can be released at any
time during runtime.
malloc() function
 malloc () is used to allocate a fixed amount of memory during
the execution of a program.
 malloc () allocates size_in_bytes of memory from heap, if
the allocation succeeds, a pointer to the block of memory is
returned else NULL is returned.
 Allocated memory space may not be contiguous.
 Each block contains a size, a pointer to the next block, and the
space itself.
 The blocks are kept in ascending order of storage address, and the
last block points to the first.
 The memory is not initialized. It initializes each block with default
garbage value.
malloc() function
Syntax Description
ptr_var = (cast_type *)
malloc (size_in_bytes); This statement returns a pointer to size_in_bytes of
uninitialized storage, or NULL if the request cannot be
satisfied.

Example: fp = (int *)malloc(sizeof(int) *20);

Example ::
ptr = (int*) malloc(100 * sizeof(int));

Since the size of int is 4 bytes, this statement will allocate 400 bytes of memory. And, the
pointer ptr holds the address of the first byte in the allocated memory.
 Example(Pointer1.c)
#include <stdio.h>
#include <stdlib.h> else {

int main() // Memory has been successfully allocated

{
printf("Memory successfully
// This pointer will hold the allocated using malloc.\n");
// base address of the block created
int* ptr; // Get the elements of the array
int n, i; for (i = 0; i < n; ++i) {
ptr[i] = i + 1;
// Get the number of elements for the array }
n = 5;
printf("Enter number of elements: %d\n", n); // Print the elements of the array

// Dynamically allocate memory using malloc() printf("The elements of the array are:
ptr = (int*)malloc(n * sizeof(int)); ");
for (i = 0; i < n; ++i) {
// Check if the memory has been successfully printf("%d, ", ptr[i]);
// allocated by malloc or not }
if (ptr == NULL) { }

printf("Memory not allocated.\n"); return 0;

exit(0); }
}
calloc() function
 “calloc” or “contiguous allocation” method in C is used to
dynamically allocate the specified number of blocks of memory of
the specified type.
 calloc() allocates a region of memory to hold no_of_blocks
of size_of_block each, if the allocation succeeds then a
pointer to the block of memory is returned else NULL is
returned.
 It initializes each block with a default value ‘0’.
calloc() function
Syntax Description
ptr_var = (cast_type *)
calloc (no_of_blocks, This statement returns a pointer to no_of_blocks of
size_of_block); size size_of_blocks, it returns NULL if the request
cannot be satisfied.

Example:
int n = 20;
fp = (int *)calloc(n, sizeof(int));

Example ::
ptr = (float*) calloc(25, sizeof(float));
This statement allocates contiguous space in memory for 25 elements each with the size of
the float.
 Example(calloc1.c)
#include <stdio.h>
#include <stdlib.h> else {

int main() // Memory has been successfully

{ allocated
printf("Memory successfully allocated
// This pointer will hold the using calloc.\n");
// base address of the block created
int* ptr; // Get the elements of the array
int n, i; for (i = 0; i < n; ++i) {
ptr[i] = i + 1;
// Get the number of elements for the array }
n = 5;
printf("Enter number of elements: %d\n", n); // Print the elements of the array
printf("The elements of the array
// Dynamically allocate memory using calloc() are: ");
ptr = (int*)calloc(n, sizeof(int)); for (i = 0; i < n; ++i) {
printf("%d, ", ptr[i]);
// Check if the memory has been successfully }
// allocated by calloc or not }
if (ptr == NULL) {
printf("Memory not allocated.\n"); return 0;
exit(0);
}
free() method
 “free” method in C is used to dynamically de-allocate the
memory.
 The memory allocated using functions malloc() and calloc() is not
de-allocated on their own.
 Hence the free() method is used, whenever the dynamic memory
allocation takes place.
 It helps to reduce wastage of memory by freeing it.
free() method
 Syntax::
• free(ptr);
 Example
#include <stdio.h>
#include <stdlib.h> else {

int main() // Memory has been successfully

{ allocated
printf("Memory successfully allocated
// This pointer will hold the using malloc.\n");
// base address of the block created
int *ptr, *ptr1; // Free the memory
int n, i; free(ptr);
printf("Malloc Memory successfully
// Get the number of elements for the array freed.\n");
n = 5;
printf("Enter number of elements: %d\n", n); // Memory has been successfully
allocated
// Dynamically allocate memory using malloc() printf("\nMemory successfully
ptr = (int*)malloc(n * sizeof(int)); allocated using calloc.\n");

// Dynamically allocate memory using calloc() // Free the memory

ptr1 = (int*)calloc(n, sizeof(int)); free(ptr1);
printf("Calloc Memory successfully
// Check if the memory has been successfully freed.\n");
// allocated by malloc or not }
if (ptr == NULL || ptr1 == NULL) {
printf("Memory not allocated.\n"); return 0;
exit(0); }
}
realloc() method
 “realloc” or “re-allocation” method in C is used to dynamically
change the memory allocation of a previously allocated memory.
 In other words, if the memory previously allocated with the help
of malloc or calloc is insufficient, realloc can be used
to dynamically re-allocate memory.
 re-allocation of memory maintains the already present value and
new blocks will be initialized with default garbage value.
Syntax Description
ptr_var = (cast_type *) This statement returns a pointer to new space, or NULL if
realloc (void *fp,
size_t); the request cannot be satisfied.

Example:
fp = (int *)realloc(fp,sizeof(int)*20);
 realloc() method
Example ::

ptr = realloc(ptr, newSize);

where ptr is reallocated with new size 'newSize'.