Dynamic Memory
Allocation
1
Memory Layout of C Program
In practical words, when we run any C-program, its
executable image is loaded into RAM of computer in an
organized manner.
2
Memory Layout of C Program
1>Text or Code Segment :-Text segment
contains machine code of the compiled
program. The text segment of an executable
object file is often read-only segment that
prevents a program from being accidentally
modified.
3
Memory Layout of C Program
2>Initialized Data Segment :-Initialized data
stores all global, static, constant, and
external variables (declared with extern
keyword ) that are initialized beforehand.
Data segment is not read-only, since the
values of the variables can be altered at run
time.
4
Memory Layout of C Program
3>Uninitialized Data Segment (bss):-Data in
this segment is initialized to arithmetic 0
before the program starts executing.
Uninitialized data starts at the end of the data
segment and contains all global variables and
static variables that are initialized to 0 or do
not have explicit initialization in source code.
5
Memory Layout of C Program
4>Heap:-Heap is the segment where
dynamic memory allocation usually takes
place. When some more memory need to be
allocated using malloc and calloc function,
heap grows upward. The Heap area is
shared by all shared libraries and
dynamically loaded modules in a process.
6
Memory Layout of C Program
5>Stack:-Stack segment is used to store all local variables
and is used for passing arguments to the functions along
with the return address of the instruction which is to be
executed after the function call is over. Local variables have
a scope to the block which they are defined in, they are
created when control enters into the block. All recursive
function calls are added to stack.
The stack and heap are traditionally located at opposite ends
of the process's virtual address space.
7
Problem with Arrays
Sometimes
Amount of data cannot be predicted beforehand
Number of data items keeps changing during program execution
Example: Search for an element in an array of N elements
One solution: find the maximum possible value of N and allocate
an array of N elements
Wasteful of memory space, as N may be much smaller in some
executions
Example: maximum value of N may be 10,000, but a particular
run may need to search only among 100 elements
Using array of size 10,000 always wastes memory in most
cases
8
Better Solution
Dynamic memory allocation
Know how much memory is needed after the program
is run
Example: ask the user to enter from keyboard
Dynamically allocate only the amount of memory
needed
C provides functions to dynamically allocate
memory
malloc, calloc, realloc
9
Memory Allocation Functions
malloc
Allocates requested number of bytes and returns a
pointer to the first byte of the allocated space
calloc
Allocates space for an array of elements, initializes
them to zero and then returns a pointer to the
memory.
free
Frees previously allocated space.
realloc
Modifies the size of previously allocated space.
10
Allocating a Block of Memory
A block of memory can be allocated using the
function malloc
Reserves a block of memory of specified size
and returns a pointer of type void
The return pointer can be type-casted to any
pointer type
General format:
type *p;
p = (type *) malloc (byte_size);
11
Example
p = (int *) malloc(100 * sizeof(int));
A memory space equivalent to 100 times
the size of an int bytes is reserved
The address of the first byte of the
allocated memory is assigned to the
pointer p of type int
p
400 bytes of space 12
Contd.
cptr = (char *) malloc (20);
Allocates 20 bytes of space for the pointer cptr
of type char
Always use sizeof operator to find number of bytes for
a data type, as it can vary from machine to machine
13
Points to Note
malloc always allocates a block of contiguous bytes
The allocation can fail if sufficient contiguous
memory space is not available
If it fails, malloc returns NULL
if ((p = (int *) malloc(100 * sizeof(int))) == NULL)
{
printf (“\n Memory cannot be allocated”);
exit();
}
14
Using the malloc’d Array
Once the memory is allocated, it can be used with
pointers, or with array notation
Example:
int *p, n, i;
scanf(“%d”, &n);
p = (int *) malloc (n * sizeof(int));
for (i=0; i<n; ++i)
scanf(“%d”, &p[i]);
The n integers allocated can be accessed as *p, *(p+1),
*(p+2),…, *(p+n-1) or just as p[0], p[1], p[2], …,p[n-1]
15
Releasing the Allocated Space:
free
An allocated block can be returned to the
system for future use by using the free function
General syntax:
free (ptr);
where ptr is a pointer to a memory block which
has been previously created using malloc
Note that no size needs to be mentioned for the
allocated block, the system remembers it for
each pointer returned
16
Allocation Examples
p1 = malloc(4*sizeof(int))
p2 = malloc(5*sizeof(int))
p3 = malloc(6*sizeof(int))
free(p2)
p4 = malloc(2*sizeof(int))
17 Dynamic Memory Allocation
calloc()
“calloc” or “contiguous allocation” method in C is used to
dynamically allocate the specified number of blocks of
memory of the specified type. it is very much similar to
malloc() but has two different points and these are:
It initializes each block with a default value ‘0’.
It has two parameters or arguments as compare to
malloc().
If space is insufficient, allocation fails and returns a NULL
pointer.
18 Dynamic Memory Allocation
calloc()
19 Dynamic Memory Allocation
recalloc()
“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 the
default garbage value.
If space is insufficient, allocation fails and returns a NULL
pointer.
20 Dynamic Memory Allocation
recalloc()
21 Dynamic Memory Allocation
