Module 08: Functions, Storage Classes & Recursion Call Stack

1. Prototypes & Pass-by-Value 1 / 4

Function Prototypes & Call-by-Value Semantics

Why C is strictly pass-by-value and how pointers simulate reference

In C, function arguments are copied by value. The called function receives an isolated local copy on its stack frame, meaning modifying the parameter inside the function does not change the caller's variable.

pass_by_value.c

// Forward Prototype Declaration:
void swap_failed(int a, int b);
void swap_correct(int *a, int *b);

int main(void) {
    int x = 10, y = 20;
    swap_failed(x, y);    // DOES NOT SWAP: x and y remain 10 and 20
    swap_correct(&x, &y); // SWAPS: Passes memory addresses so function can mutate RAM
    return 0;
}

2. Storage Classes 2 / 4

Storage Classes: auto, register, static & extern

Controlling variable scope, lifetime, and linkage across files

Class	Memory Location	Scope	Lifetime	Default Value
`auto`	Stack	Block scope	Function call duration	Garbage
`register`	CPU Register	Block scope	Function call duration	Garbage
`static` (Local)	Data/BSS segment	Block scope	Entire program run	Zero (0)
`static` (Global)	Data/BSS segment	File scope only (Internal Linkage)	Entire program run	Zero (0)
`extern`	Data/BSS segment	Global across files (External Linkage)	Entire program run	Defined elsewhere

3. Recursion & Stack Frames 3 / 4

Recursion Mechanics & Stack Activation Records

How recursive calls push frames onto the Stack

Every recursive call allocates a new Activation Record (Stack Frame) containing the caller return address, parameters, and local variables:

recursion_stack.c

uint64_t factorial(uint32_t n) {
    // 1. BASE CASE: Prevents infinite recursion and stack overflow
    if (n <= 1) return 1;

    // 2. RECURSIVE STEP: Pushes new stack frame
    return n * factorial(n - 1);
}

4. Tail Call Optimization 4 / 4

Tail Recursion & Compiler Tail-Call Optimization (TCO)

Transforming recursive O(n) stack memory into O(1) iterative speed

When the recursive call is the final operation in a function with no trailing arithmetic, modern compilers replace stack frame allocations with a direct jump:

tail_recursion.c

// Tail recursive helper with accumulator parameter:
uint64_t fact_tail(uint32_t n, uint64_t acc) {
    if (n <= 1) return acc;
    return fact_tail(n - 1, n * acc); // Tail call: 0 bytes stack growth!
}

Module 08: Functions, Storage Classes & Recursion Call Stack

Function Prototypes & Call-by-Value Semantics

Storage Classes: auto, register, static & extern

Recursion Mechanics & Stack Activation Records

Tail Recursion & Compiler Tail-Call Optimization (TCO)

1. Local Static Variables in Action

2. Practice Exercises & Solutions