functions with heap and stack

Disclaimer: This presentation is prepared by trainees of baabtra as a part of mentoring program. This is not official document of baabtra –Mentoring PartnerBaabtra-Mentoring Partner is the mentoring division of baabte System Technologies Pvt . Ltd

Functions with heap and stack

Jaseena A Pjsnp65@gmail.comwww.facebook.com/Jaseena

Muhammed A Ptwitter.com/usernamein.linkedin.com/in/profilename9539443588

WHAT IS THE STACK?

The stack is a LIFO structure similar to packing items in a box

•The last item placed into the box is the first item removed from the box.

•However, the stack –like the box –has a fixed size and should NOT be overflowed.

PUSH

POP

WHAT IS THE HEAP? A heap is a binary tree T that stores a key-element

pairs at its internal nodes

It satisfies two properties:• MinHeap: key(parent) key(child)• [OR MaxHeap: key(parent) ≥ key(child)]• all levels are full, except the last one, which is left-filled

4

6

207

811

5

9

1214

15

2516

WHAT IS THE HEAP?(contd..)

EXAMPLE FOR A MIN HEAP

MEMORYWhat is memory?

Huge linear array of storage

How is memory divided?

Kernel space and user space

Who manages memory?

OS assigns memory to processesProcesses manage the memory they’ve been assigned

MEMORY ALLOCATION Memory allocation is a process by which computer programs

and services are assigned with physical or virtual memory space.

Memory allocation is primarily a computer hardware operation but is managed through operating system and software applications.

Programs and services are assigned with a specific memory as per their requirements when they are executed. Once the program has finished its operation or is idle, the memory is released and allocated to another program or merged within the primary memory.

ALLOCATION WITH STACKWhen we have a declaration of the form “int a;”:

a variable with identifier “a” and some memory allocated to it is created in the stack. The attributes of “a” are:

• Name: a• Data type: int• Scope: visible only inside the function it is defined, disappears once

we exit the function• Address: address of the memory location reserved for it. Note: Memory is allocated in the stack for a even before it is initialized.• Size: typically 2 bytes• Value: Will be set once the variable is initialized

Since the memory allocated for the variable is set in the beginning itself, we cannot use the stack in cases where the amount of memory required is not known in advance. This motivates the need for HEAP

ALLOCATION WITH STACK(CONTD..)

The stack is a fixed block of memory, divided into two parts:

•Allocated memory used by the function that called the current function, and the function called it etc.

•Free memory that can be allocated

The borderline between the two areas is called the top of stack and is represented by the stack pointer (SP), which is a dedicated processor register

Memory is allocated on the stack by moving the stack pointer

ALLOCATION WITH STACK(CONTD..)

very fast access

ALLOCATION WITH STACK(CONTD..)

The main advantage of the stack is that functions in different parts of the program can use the same memory space to store their data

Unlike a heap, a stack will never become fragmented or suffer from memory leaks

It is possible for a function to call itself—a recursive function—and each invocation can store its own data on the stack

ALLOCATION WITH STACK(CONTD..)

AN EXAMPLE#include<stdio.h>int factor(int );void main(){ int n,fact; printf("Enter the number\n"); scanf("%d",&n); fact=factor(n); printf("Facorial is %d",fact);}int factor(int n){ int fct; if(n==0) fct=1; else fct=n*factor(n-1); return fct;}

Suppose n=4Main()

n-2 bytesFact-2bytes

Factor(4)

fct-2bytes

Factor(3)

Factor(2)

Factor(1)

Factor(0)

fct-2bytes

fct-2bytes

fct-2bytes

fct-2bytes

Order of de-allocation

PROBLEMS WITH STACK The way the stack works makes it impossible to store

data that is supposed to live after the function returns. The following function demonstrates a common programming mistake. It returns a pointer to the variable x, a variable that ceases to exist when the function returns:

int*MyFunction() { intx; /* Do something here. */ return &x; /* Incorrect */ }

PROBLEMS WITH STACK(contd..)

Another problem is the risk of running out of stack. This will happen when one function calls another, which in turn calls a third, etc., and the sum of the stack usage of each function is larger than the size of the stack.

(STACK OVERFLOW) •The risk is higher if large data objects are stored on the stack, or when recursive functions are stored.

AN EXAMPLE#include<stdio.h>int factor(int );void main(){ int n,fact; printf("Enter the number\n"); scanf("%d",&n); fact=factor(n); printf("Facorial is %d",fact);}int factor(int n){ int fct; fct=n*factor(n-1); return fct;}

Main()-4 bytesSuppose n=4

Factor(4)-2 bytes

Factor(3)-2 bytes

Factor(2)-2 bytes

Factor(1)-2 bytes

Factor(0)-2 bytes

Factor(-1)-2 bytes

STACK OVERFLOW!!!

16

byte

s

PROBLEMS WITH STACK(contd..)

If the given stack size is too large, RAM will be wasted

If the given stack size is too small, two things can happen, depending on where in memory ,the stack is located:

•Variable storage will be overwritten, leading to undefined behavior.

•The stack will fall outside of the memory area, leading to an abnormal termination.

ALLOCATION WITH HEAP

•The heap is an area of memory reserved for dynamic memory allocation

•When an application needs to use a certain amount of memory temporarily it can allocate, or borrow, this memory from the heap by calling the malloc( ) function in C or by using the 'new' operator in C++

•When this memory is no longer needed it can be freed up by calling free( ) or by using the delete operator. Once the memory is freed it can reused by future allocations

ALLOCATION WITH HEAP(contd..)•Variables can be accessed globally

•No limit on memory size

•(Relatively) slower access

•No guaranteed efficient use of space, memory may become fragmented over time as blocks of memory are allocated, then freed

•Programmer must manage memory (he/she is in charge of allocating and freeing variables)•Variables can be resized using realloc()

AN EXAMPLE#include <stdio.h>int *sum(int *a,int *b){ int *c=malloc(sizeof(int)); /*find the sum here*/ return c;//return the sum}Void main(){ int *x=malloc(sizeof(int)); int *y=malloc(sizeof(int)); int *z=malloc(sizeof(int)); /*read x and y*/ z=sum(x,y); /*print the sum*/ free(x); free(y); free(z);}

POTENTIAL PROBLEMS(contd..) Most common problems with dynamic memory

allocation occurs when blocks of memory of varying size are frequently allocated and freed.

•When memory is freed, there will be a memory hole

•This can be a problem if the next allocation is larger than any of the available hole.

•This can lead to difficulties in debugging since the total amount of free space on the heap may be sufficient for a desired allocation but allocation may fail since the free space is not contiguous.

POTENTIAL PROBLEMS(contd…)

7 bytes

12 bytes

STACK VS HEAP MEMORY ALLOCATIONSTACK HEAP

Very fast access (Relatively) slower access

Don't have to explicitly de-allocate variables Explicit de-allocation is needed.

Space is managed efficiently by OS, memory will not become fragmented

No guaranteed efficient use of space, memory may become fragmented over time as blocks of memory are allocated, then freed

Local variables only Variables can be accessed globally

Limit on stack size (OS-dependent) No limit on memory size

Variables cannot be resized variables can be resized using realloc()

THANK YOU

If this presentation helped you, please visit our page facebook.com/baabtra and like it.

Thanks in advance.

www.baabtra.com | www.massbaab.com |www.baabte.com

Contact Us

Emarald Mall (Big Bazar Building)Mavoor Road, Kozhikode,Kerala, India.Ph: + 91 – 495 40 25 550

NC Complex, Near Bus StandMukkam, Kozhikode,Kerala, India.Ph: + 91 – 495 40 25 550

Start up VillageEranakulam,Kerala, India.

Email: info@baabtra.com