Return Values and How Functions Communicate Results

The Detour a Function Call Creates

A function call is a detour in the normal path of program execution. The program reaches a call in the caller, redirects execution into the function body, and then returns to the caller after the function completes. Understanding this detour is the foundation for tracing return values and explaining how functions communicate results to the code that called them.

Tracing the Rectangle Calculation

Consider the source-pack scenario of a program that calculates the area of a rectangle by calling a helper function. The important point is not the arithmetic itself. The important point is the movement of execution: the main program reaches the helper-function call, execution moves into the helper function, and execution returns to the main program when the helper finishes.

1. Execution begins in the main program rather than inside the helper function merely because the helper appears earlier in the file.
2. The main program reaches the statement that calls the rectangle-area helper function.
3. The call redirects execution into the helper function's body.
4. The helper function completes its work.
5. Execution returns to the caller, allowing the main program to continue with the statement after the call.

How the Call Stack Finds the Return Point

The program needs to remember where it was in the caller before it enters a function. The call stack provides that memory. Each time a function is called, the program stores information about the current location, called the return address, on the call stack. When the function completes, the program removes that return address from the stack and uses it to jump back to the correct place in the caller.

The same mechanism also works when functions call other functions. Each new call pushes another return address onto the call stack. Each completed call pops one return address off. This lets the program return through nested calls in the correct order rather than losing track of earlier callers.

Following Results Back to the Caller

A function is useful to its caller because the caller can rely on the function to complete a separate piece of work and then return control. In a calculation such as the rectangle-area scenario, the work performed inside the helper produces the calculation's result. Once the helper completes, execution is back in the caller, where the program can continue using the outcome of that call.

Predicting the Next Execution Point

Mistakes in Execution Tracing

• Assuming functions execute in the order in which their definitions appear in the file.

  Execution starts at the main program or first executable statement and enters a function when that function is called.

  Fix: Find the starting executable statement, then follow each function call as a redirection of execution.

• Assuming execution remains in the caller while the called function performs its work.

  A function call redirects execution into the function body before the caller continues.

  Fix: Pause the caller at the call, trace the function body, and continue only after the function completes.

• Ignoring the return address when tracing nested calls.

  Each call stores a return address on the call stack, and each return uses one saved address.

  Fix: Track each call as a push of a return address and each completion as a pop of one return address.

Key Takeaways

1. A function call redirects execution from the caller into the function body.
2. After the function completes, execution returns to the caller.
3. The call stack stores return addresses so the program knows where to resume.
4. Nested calls work because each call pushes a return address and each return pops one.
5. Tracing calls and returns helps explain results and debug unexpected program behavior.