Normal programs use a
call stack to make this possible. That is, a function and its local variables get added to the stack, and any functions it calls gets added to the stack... actually, here's a small sample:
void a()
{
int x;
x = 2;
}
void b(float y)
{
std::cout << (y * 2);
a();
}
void ab()
{
float theta;
theta = 3.14f;
b(theta);
std::cout << theta;
}
/*
Call stack at beginning: empty
+--------------+
| | <-stack pointer points to this (empty/non-existent) frame
+--------------+
Now you call ab(), so it gets pushed onto the stack:
+--------------+
| function: ab | <-stack pointer points to this frame
| - - - |
| theta | <-space for local variables on the stack
+--------------+
ab() calls b():
+--------------+
| function: ab |
| - - - |
| theta |
+--------------+
| function: b | <-stack pointer points to this frame
| - - - |
| y | <-space for parameters (like local variables)
+--------------+
and b() calls a(), so a() gets pushed to the stack and a frame is created for it, just like with the last two:
+--------------+
| function: ab |
| - - - |
| theta |
+--------------+
| function: b |
| - - - |
| y |
+--------------+
| function: a | <-stack pointer points to this frame
| - - - |
| x |
+--------------+
Notice how none of them mess with each other's local variables?
Now a() finishes executing and returns, so it gets popped from the stack:
+--------------+
| function: ab |
| - - - |
| theta |
+--------------+
| function: b | <-stack pointer points to this frame
| - - - |
| y |
+--------------+
*The frame for a() that was here is longer*
And then b() finishes executing and returns, so it gets popped from the stack:
+--------------+
| function: ab | <-stack pointer points to this frame
| - - - |
| theta |
+--------------+
*The frame for b() that was here is longer*
*/
I know this doesn't show return values for the functions, but that doesn't require much work. Once you get the idea of how a call stack works, adding return values is just a matter of making space for it on the stack and filling that space with the right value.
I've also simplified it quite a bit. In real life, there's a few other things that get stored to the stack when you call a function, like your important registers. But again, anything you want to be preserved when you call a function, just make room for it (where the other variables are) on the stack, store them on the stack, and call the other function.
[edit]
Ooohh, just found
this.
