The document discusses stacks and their applications. A stack is an ordered group of homogeneous elements that are added and removed from the top. Elements are removed in LIFO (last in, first out) order. Stacks have push and pop operations to add and remove elements from the top. Common applications include stack frames for function calls, reversing a string, and converting expressions. Stack frames use stacks to store local variables and function calls, with each function getting its own stack frame.

1. Stacks

2. What is a stack?
• It is an ordered group of homogeneous
items of elements.
• Elements are added to and removed
from the top of the stack (the most
recently added items are at the top of
the stack).
• The last element to be added is the
first to be removed (LIFO: Last In, First
Out).

4. Push Operation
• Function: Adds new Item to the top of
the stack.
• Preconditions: Stack has been
initialized and is not full.
• Post conditions: new Item is at the top
of the stack.

5. Pop operation
• Function: Removes topItem from stack
and returns with topItem
• Preconditions: Stack has been
initialized and is not empty.
• Postconditions: Top element has been
removed from stack and the function
returns with the top element.

11. Stack Applications
1.Stack frames
2.Reversing a string
3.Conversion of
expressions

12. Stack frames
Stack frames is one of the segments of application
memory that is used to store the local variables,
function calls of the function.
Whenever there is a function call in our program the
memory to the local variables and other function calls
or subroutines get stored in the stack frame.
Each function gets its own stack frame in the stack
segment of the application’s memory.

13. • The memory allocated for a function call in the stack lives only the
time when the function is executing once the function gets completed
we can’t access the variables of that function.
• Once the calling function completes its execution its stack frame is
removed.
• Stack is used for storing function calls so in the case when we are
using a lot of recursive calls in our program the stack memory gets
exhausted by the function calls or subroutines which may result in
stack overflow because the stack memory is limited.
• Whenever a function call is made a stack frame is created in the stack
segment the arguments that were given by the calling function get
some memory in the stack frame , and they get pushed into that stack
frame . When their execution is finished they get popped from the
stack frame. And the thread of execution gets continues in the called
function.

14. //findSum method
int findSum(int a, int b)
{
int sum = a + b;
return sum;
}
//main function
int main()
{
int a = 6;
int b = 6;
int sum = findSum(a, b); // findSum method called
cout << "Sum is :" << sum ;
return 0;
}
Output :
Sum is :12

15. Explanation using Stack :
When main() calls findSum(a, b) function a new
stack frame is created as follows.
findSum()
a = 6
b=6
Sum is = a+ b

36. Subprogram calls
&execution
• A Subprogram is a program inside any larger program that
can be reused any number of times.
• Main Program is suspended during the execution of any
subprogram. Moreover, after the completion of the
subprogram the main program executes from the next
sequential address present in the Program Counter .
• For the implementation of any subprogram, a “Stack” is
used to store the “Return Address” to the Main Program .
Here, Return Address means the immediately next
instruction address after the Call Instruction in the Main
program. This Return Address is present inside the Program
Counter

37. • Thus during the execution of the Subprogram
function Call , the Program Counter(PC) value is
first pushed to the Stack as the Return Address
• And then the Program Counter value is updated to
the given address in the Call Instruction
• Similarly, during the execution of Return(Ret)
Instruction, the value present in the stack is popped
and the Program Counter value is restored for
further execution of the Main Program .
• The Main advantage of Subprogram is that it avoids
repetition of Code and allows us to reuse the same
code again and again.

39. Subprograms calls & Execution in C++
// Subprogram function
int findSum(int a, int b)
{
int sum = a + b;
return sum;
}
//main program
int main()
{
int a = 6;
int b = 6;
int sum = findSum(a, b); // findSum method called
cout << "Sum is :" << sum ;
return 0;
}
Output :
Sum is :12