Scribd
Upload
13 views15 pages

Chapter 12

This document discusses dynamic memory management in C using pointers and functions like malloc(), calloc(), realloc() and free(). Some key points: - Dynamic memory allocation happens at runtime using functions like malloc(), calloc() which allocate memory and return a pointer to the allocated memory. - realloc() is used to change the size of previously allocated memory. - free() deallocates or frees up memory that is no longer needed. - malloc() allocates contiguous memory while calloc() allocates multiple blocks of same size memory. - Pointers store the address of the memory location. Pointer arithmetic and dereferencing (*) operator are used to access data in

Uploaded by

alnajath1
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
13 views15 pages

Chapter 12

This document discusses dynamic memory management in C using pointers and functions like malloc(), calloc(), realloc() and free(). Some key points: - Dynamic memory allocation happens at runtime using functions like malloc(), calloc() which allocate memory and return a pointer to the allocated memory. - realloc() is used to change the size of previously allocated memory. - free() deallocates or frees up memory that is no longer needed. - malloc() allocates contiguous memory while calloc() allocates multiple blocks of same size memory. - Pointers store the address of the memory location. Pointer arithmetic and dereferencing (*) operator are used to access data in

Uploaded by

alnajath1
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 15

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?

You might also like