Keeping track of nested invocation calls in a procedural

programming language, such as C/C++.

Each function call results in a new entry being placed into

the program run-time stack. This new

entry contains memory space for local variables (which can

grow dynamically) and for a return

pointer to the instruction in the function that invoked the

current function (caller/callee). As

functions terminate, their stack entry is "popped out," with

the return values written to the proper

location in the caller.

Since nested procedural/ function invocation levels are

entered and exited in LIFO order, a stack

is the most appropriate data structure to handle this

functionality.

Evaluating arithmetic expressions.

Stacks can be used to parse arithmetic expressions and

evaluate them efficiently, as we shall

see as part of this assignment.

To eliminate the need for direct implementation of recursion.

As recursive function calls require a lot of overhead, it is

often the case that recursive algorithms

are "unrolled" into non-recursive ones. Since recursive

calls are entered/exited in LIFO order the

use of stacks to mimic recursion is a natural choice.