Dynamic Memory Allocation

Statistics of Rainfall
The weather station of each city has the detail
of rainfall in a year. Given the date and cm of
rainfall recorded on that day, write a C
program to determine the rainfall recorded in
each month of the year and average monthly
rainfall in the year.
 Rainfall problem

Input Output Logic Involved

Details of Rainfall Find sum of values

rainfall recorded recorded for for each month
in the year each month and then
(Date and cm of and monthly determine monthly
rainfall) average average
 Implementation in C
• For storing each row of the table we need a
structure and we may use array of structures for
storing details
• Memory allocation for arrays – Statically done
• But number of days varies from city to city...
• Cherrapunji has 170 rainy days on average
• Rajasthan gets least rainfall and receives only rainfall for
30 days in a year.
 Static Vs Dynamic Memory Allocation
• If we declare an array of size 180 then for a city
that has less rainfall wastage of memory
• If the programmer declares an array of size 50
then there will be shortage of memory.
• It is better to get the number of raining days from
the user during execution of program and
allocate memory
• C supports dynamic memory allocation
• Allocates a chunk of memory and returns the
address of first byte
 Allocation of Memory
• Static Allocation: Allocation of memory space
when execution begins.

• Dynamic Allocation: Allocation of memory

space at run time.
 Pointers
• Variable that contains address in memory of
another variable.
• We can have a pointer to any variable type.
• Unary or monadic operator & gives the ``address
of a variable''.
• Indirection or dereference operator * gives the
``contents of an object pointed to by a pointer''.
• To declare a pointer to a variable :
• datatype * name_Of_Variable;  
Eg: int *pointer;
 Pointers
void main () {
int num = 3;
int *nump = #
…..
Assignment of Pointer Variables (Cont ..)

FFF0
FFF1

float data = 50.8; FFF2

float *ptr; FFF3

ptr = &data; data FFF4 50.8
FFF5
FFF6
Assignment of Pointer Variables

ptr FFF0
FFF1

float data = 50.8; FFF2

float *ptr; FFF3

ptr = &data; data FFF4 50.8
FFF5
FFF6
Assignment of Pointer Variables

ptr FFF0 FFF4

FFF1

float data = 50.8; FFF2

float *ptr; FFF3

ptr = &data; data FFF4 50.8
FFF5
FFF6
 Assignment of Pointer Variables
• Don’t try to assign a specific integer value to a pointer
variable since it can be disastrous
• You cannot assign the address of one type of
float *ptr;
variable to a pointer variable of another type
ptr = 120;
even though they are both integrals
int data = 50;
float *ptr;
ptr = &data;
 Initializing pointers

• If a pointer is not initialized during declaration, it is

wise to give it a NULL value
float *fp = NULL;
 The NULL pointer

• The NULL pointer is a valid address for any

data type.
– But NULL is not memory address 0.
• It is an error to dereference a pointer whose
value is NULL.
– Such an error may cause your program to crash,
or behave erratically.
– It is the programmer’s job to check for this.
 Dereferencing Example
#include <iostream.h>
ptr FFF0 FFF4
void main()
{ FFF1
float data = 50.8; FFF2
float *ptr;
FFF3
ptr = &data;
cout << ptr << *ptr << endl; data FFF4 50.8
*ptr = 27.4; FFF5
cout << *ptr << endl;
cout << data << endl; FFF6
}

Output:
 Dereferencing Example
#include <iostream.h>
ptr FFF0 FFF4
void main()
{ FFF1
float data = 50.8; FFF2
float *ptr;
FFF3
ptr = &data;
cout << ptr << *ptr << endl; data FFF4 50.8
*ptr = 27.4; FFF5
cout << *ptr << endl;
cout << data << endl; FFF6
}

Output:

FFF4 50.80
 Dereferencing Example
#include <iostream.h>
ptr FFF0 FFF4
void main()
{ FFF1
float data = 50.8; FFF2
float *ptr;
FFF3
ptr = &data;
cout << ptr << *ptr << endl; data FFF4 27.4
*ptr = 27.4; FFF5
cout << *ptr << endl;
cout << data << endl; FFF6
}

Output:
 Dereferencing Example
#include <iostream.h>
ptr FFF0 FFF4
void main()
{ FFF1
float data = 50.8; FFF2
float *ptr;
FFF3
ptr = &data;
cout << ptr << *ptr << endl; data FFF4 27.4
*ptr = 27.4; FFF5
cout << *ptr << endl;
cout << data << endl; FFF6
}

Output:

27.4
 Dereferencing Example (Cont ..)
#include <iostream.h>
ptr FFF0 FFF4
void main()
{ FFF1
float data = 50.8; FFF2
float *ptr;
FFF3
ptr = &data;
cout << ptr << *ptr << endl; data FFF4 27.4
*ptr = 27.4; FFF5
cout << *ptr << endl;
cout << data << endl; FFF6
}

Output:

27.4
 Operations on Pointer Variables
• Assignment – the value of one pointer variable can
be assigned to another pointer variable of the same
type
• Relational operations - two pointer variables of the
same type can be compared for equality, and so on
• Some limited arithmetic operations
– integer values can be added to and subtracted
from a pointer variable
– value of one pointer variable can be subtracted
from another pointer variable
 Pointers to arrays
• A pointer variable can be used to access the elements
of an array of the same type.
int gradeList[8] = {92,85,75,88,79,54,34,96};
int *myGrades = gradeList;
cout << gradeList[1];
cout << *myGrades;
cout << *(myGrades + 2);
cout << myGrades[3];
• Note that the array name gradeList acts like the
pointer variable myGrades.
 Arithmetic Operators and Pointers
• Four arithmetic operators can be used on
pointers: ++, --, +, and –
•  Consider that ptr is an integer pointer which
points to the address 1000
• Assume 4 bytes are allocated for integers
• After the following operation
ptr++
ptr will point to location 1004
• On integer pointers -- will decrement by 4
 Arithmetic Operators and Pointers
• Adding 1 will also be done based on the type of
pointer
• If it is character pointer then 1 is added to the
pointer variable
• If the pointer is of type double then 8 is added to the
pointer variable
• Subtraction is also completely based on the type of
pointer variable
 Arrays and Pointers
• An array name in C contains the address of the
byte of memory allocated
• But array name is a “Pointer Constant”

• Value cannot be changed

• ++ operator cannot be applied directly

• Therefore base address of array is copied into a
pointer variable and the operation is performed
 Example for Arrays and Pointers
const int MAX = 3;
int main ()
{ int var[] = {10, 100, 200};
int i, *ptr;
/* let us have array address in pointer */
ptr = var;
for ( i = 0; i < MAX; i++)
{ printf("Address of var[%d] = %x\n", i, ptr );
printf("Value of var[%d] = %d\n", i, *ptr );
/* move to the next location */
ptr++;
}
return 0; }
 Pointer Comparisons
• Pointers may be compared by using relational
operators, such as ==, <, and >
const int MAX = 3;
int main ()
{
int var[] = {10, 100, 200};
int i, *ptr;
// let us have address of the first element in pointer
ptr = var;
i = 0;
 Pointer Comparisons
while ( ptr <= &var[MAX - 1] )
{
printf("Address of var[%d] = %x\n", i, ptr );
printf("Value of var[%d] = %d\n", i, *ptr );
/* point to the previous location */
ptr++;
i++;
}
return 0;
}
 Pointer to an Array and Array of Pointers

 int (*a)[35]; - declares a pointer to an array of

35 ints. 

int *a[35]; - declares an array of 35 pointers

to ints. 
  Double Pointer
Pointer to pointer
int  **ptr2ptr;

Example:
int num = 45 , *ptr , **ptr2ptr ;
ptr = &num;
ptr2ptr = &ptr;
Dynamic Memory Allocation
 malloc()
• Dynamically allocates memory when required

• This function allocates ‘size’ byte of memory and

returns a pointer to the first byte or NULL if there is
some kind of error
• Syntax is as follows:
void * malloc (size_t size);
• return type is of type void *, also receive the address of
any type
 calloc()
• Used to allocate storage to a variable while the
program is running

Syntax
• void * calloc (size_t n, size_t size);

• For example, an int array of 10 elements can be

allocated as follows.
• int * array = (int *) calloc (10, sizeof (int));
 Difference between malloc() and calloc()

• Calloc allocates multiple blocks of data whereas

malloc allocates as a single block 
• Calloc initializes all bytes in the allocation block
to zero
• Allocated memory may/may not be contiguous.
 realloc()
• Modifies the allocated memory size by malloc () and calloc
() functions to new size
• If enough space doesn’t exist in memory of current block
to extend, new block is allocated for the full size of
reallocation, then copies the existing data to new block and
then frees old block
• Syntax
void * realloc (void * ptr, size_t size);
 free()
• frees the allocated memory by malloc (), calloc (),
realloc () functions and returns the memory to the
system