NINT
[ It is the process of allocating memory during
Runtime (Execution Time) ]
Dynamic Memory Management Technique NINT
Used to allocate additional memory space or to release the
unwanted memory space at runtime
Used to optimize the use of storage space
The programmer can allocate memory whenever he decides and
releases it after using the memory
malloc()
calloc()
alloc.h
realloc()
free()
NINT
Used to allocate a contiguous block of memory in
bytes.
Ptr_name= (*cast type) malloc(int size);
Example 1:
ptr=(int*)malloc(10);
Example 2 :
char (*a)[20];
A=(char*) malloc(10*20*sizeof(char));
Note :
If the memory allocation is success it returns the starting address
else if returns NULL
NINT
Used to free (release or deallocate) the block of unused or
already used memory
free(pointer_variable);
Example 1:
ptr=(int*)malloc(10);
free(ptr);
/* malloc() Function Example */ NINT
#include<stdio.h>
#include<alloc.h>
#include<process.h>
void main()
{
char *str;
if((str=(char *)malloc(10))==NULL){
printf("Not enough memory to allocate buffer\n");
exit(1);}
strcpy(str,"Helloworld");
printf("String is %s\n",str);
free(str);
}
String is HelloWorld
malloc() Example 2
NINT
#include<stdio.h>
#include<conio.h>
void main()
{
int *ptr; //static memory allocation
clrscr();
ptr=(int *) malloc(sizeof(int));
*ptr=100;
printf("\n%u\n",ptr); //address of ptr
printf("\n%d\n",*ptr);
free(ptr);
getch();
}
/* note : int *ptr=100 means 100 is a address
*ptr=100 means 100 is a value */
To allocate memory using malloc *sptr=500;
and deallocate using free
NINT
#include<stdio.h> sptr=startptr; /*assign the address of first
#include<alloc.h> data into the sptr; */
void main() for(i=0;i<5;i++)
{ {
int *sptr,i; printf("%d\n",*sptr);
int *startptr; sptr++;
sptr=(int *) malloc(sizeof(int)*5); }
startptr=sptr; /*startptr maintain the base sptr=startptr;
address(Ist Address) */
*sptr=100; free(sptr); /* take sometime for deallocation
sptr++; */
*sptr=200; sptr=NULL; /* so assign the null value
sptr++; you can't retrieve the data */
*sptr=400; startptr=NULL;
sptr++; }
*sptr=300;
sptr++;
Allocating Memory NINT
The following example uses a two-dimensional array to record
marks of 5 students for 10 subjects.
It uses pointers and malloc() function, to assign memory.
Pointer Increment process but
*ptr=300;
malloc allocates memory only for 4
ptr++; // increment 2 bytes
NINT
bytes
printf("\n ptr 4= %d\n",*ptr);
#include<stdio.h>
free(ptr);
#include<conio.h>
getch();
void main()
}
{
int *ptr; //static memory allocation
clrscr();
ptr=(int *) malloc(sizeof(int)*2);
//allocate 4 bytes
*ptr=100;
ptr++; // increment 2 bytes
printf("\n ptr 1= %d\n",*ptr);
*ptr=150;
ptr++;
printf("\n ptr 2= %d\n",*ptr);
*ptr=200;
ptr++;
printf("\n ptr 3= %d\n",*ptr);
NINT
calloc() used to allocate multiple blocks of contiguous
memory in bytes. All the blocks are of same size.
Ptr_name= (*cast type) calloc(No.of blocks,int size);
Example 1:
ptr=(int*)calloc(5,10);
On execution of this function 5 memory blocks of size 10 bytes
are allocated and the starting address of the first byte is assigned to the
pointer ptr of type int
/* Calloc() Function example */ NINT
#include<stdio.h>
#include<string.h>
#include<alloc.h>
void main()
{
char *str=NULL;
str=(char *)calloc(20,sizeof(char));
strcpy(str,"Welcome to world");
printf("String is %s\n",str);
free(str);
}
String is Welcome to World
NINT
This function used to increase or decrease the size of
memory already allocated by using malloc() or calloc()
function
newPtr_name= (*cast type) realloc(old_ptr,int newsize);
Example 1:
y=(int*)malloc(50)
ptr=(int*)realloc(y,30);
//REALLOC() FUNCTION EXAMPLE
#include<stdio.h> NINT
#include<string.h>
#include<alloc.h>
void main()
{
char *str;
str=(char *)malloc(5);
strcpy(str,"Kalai");
printf("String is %s\n Address is %u\n",str,str);
str=(char *)realloc(str,5);
strcpy(str,"Sangeetha");
printf("String is %s\n New Address is %u\n",str,str);
free(str);
}
String is Kalai address is 65524
String is Sangeetha address is 65524
Session Summary
NINT
Like all variables a pointer must be declared before they are used
The indirection (or) the deferencing operator is used to access the value of an address
in a pointer
The three values that can be used to initialize a pointer are zero, null and address
A pointer that has not been initialized is referred to as the dangling pointer
Arrays are automatically passed by reference since the value of the array name is the
address of the array
Call by reference is the process of calling a function using pointers to pass the
address as argument must include a pointer as its parameter.
NINT
EXERCISES
1. Write a program to find the largest number in an array using pointers
2. Write a program to sort the strings in alphabetical order using pointers
3. Write a program to copy one string to another using pointers
4. Write a program to reverse an array using pointers?
5. Write a program to count the number of vowels in an array of characters using
pointers?
6. Write a program to search an element in an array of “N” elements using pointers?
