Functions, recursion and storage classes notes — Unit 3

Imagine writing a 10,000-line C program inside a single `main()` function. It would be impossible to read, debug, or reuse code. A function is a self-contained block of code that performs a specific task. It takes inputs (parameters), does some work, and gives an output (return value).

A function has three crucial parts: the Declaration (Prototype), the Definition (Body), and the Call (Execution).

These two terms are constantly mixed up, but examiners often test the difference.

Every function must declare what TYPE of data it will hand back to whoever called it.

• `int`: Returns a whole number.
• `float`: Returns a decimal number.
• `char`: Returns a single character.
• `void`: Returns absolutely nothing.

If a function is marked `void`, trying to capture its output in a variable will cause a strict compiler error.

This is the most critical concept in C memory management. When you pass a variable to a function, does the function get the REAL variable, or a PHOTOCOPY?

The classic 10-mark exam question asks you to explain why a basic swap function fails.

1. 1.Step 1: `main` creates local variables x=5, y=10.
2. 2.Step 2: `badSwap(5, 10)` is called. C makes a PHOTOCOPY.
3. 3.Step 3: `badSwap` creates its own local variables: a=5, b=10.
4. 4.Step 4: `badSwap` successfully swaps its local 'a' and 'b'. Now a=10, b=5.
5. 5.Step 5: `badSwap` finishes. Its local variables 'a' and 'b' are destroyed in memory.
6. 6.Step 6: `main` prints 'x' and 'y'. They were never touched! They are still 5 and 10.

To fix this, we must pass the Memory Addresses (using `&`) and receive them in Pointers (using `*`).

Because `goodSwap` had the actual physical memory addresses of `x` and `y` from `main`, it reached directly into `main`'s memory and modified them. This is true Call by Reference.

If C uses Call-by-Value (photocopying) for everything, what happens if you pass an array of 1,000,000 integers to a function? Does C freeze while it makes 1,000,000 photocopies? NO.

Recursion is when a function calls ITSELF. It's like looking into a mirror that is reflecting another mirror.

1. 1.Let's trace `fact(4)` exactly as the computer's memory stack sees it:
2. 2.Call 1: `fact(4)`. Is 4==1? No. Return `4 * fact(3)`.
3. 3. -> Pauses Call 1. Starts Call 2.
4. 4.Call 2: `fact(3)`. Is 3==1? No. Return `3 * fact(2)`.
5. 5. -> Pauses Call 2. Starts Call 3.
6. 6.Call 3: `fact(2)`. Is 2==1? No. Return `2 * fact(1)`.
7. 7. -> Pauses Call 3. Starts Call 4.
8. 8.Call 4: `fact(1)`. Is 1==1? YES. Return 1.

The computer hit the base case. Now it has to 'unwind' the stack, feeding the answers back up the chain to the paused functions.

1. 1.Call 4 finished and returned `1` back to Call 3.
2. 2.Call 3 resumes: It was waiting for `fact(1)`. It calculates `2 * 1` = 2. Returns `2` back to Call 2.
3. 3.Call 2 resumes: It was waiting for `fact(2)`. It calculates `3 * 2` = 6. Returns `6` back to Call 1.
4. 4.Call 1 resumes: It was waiting for `fact(3)`. It calculates `4 * 6` = 24. Returns `24` back to main().

The Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8... Each number is the sum of the two before it. Finding the nth term recursively is a classic exam question.

1. 1.Trace `fib(3)`:
2. 2.fib(3) = fib(2) + fib(1)
3. 3. -> We know fib(1) = 1. But what is fib(2)?
4. 4. -> To find fib(2), it calls fib(1) + fib(0)
5. 5. -> We know fib(1) = 1, and fib(0) = 0. So fib(2) = 1 + 0 = 1.
6. 6.Return to fib(3):
7. 7.fib(3) = (1) + (1) = 2.

Every variable in C has a data type (int, float), but it also has a 'Storage Class'. This defines exactly how the variable behaves in memory.

This is the default storage class for all local variables. If you type `int x = 5;` inside a function, C secretly treats it as `auto int x = 5;`.

• Scope: Local to the block {} it is defined in.
• Lifetime: Created when the block starts, destroyed instantly when the block ends.
• Initial Value: Garbage value (random memory junk) if not initialized.
• Storage: RAM (The Stack).

Accessing RAM is slow. The CPU has tiny, ultra-fast memory slots built directly into the processor chip called 'Registers'. If you have a variable you will use millions of times (like a loop counter), you can ask C to put it in a register.

• Scope: Local.
• Lifetime: Until the block ends.
• Initial Value: Garbage.
• Storage: CPU Register (if available, otherwise fallback to RAM).

This is the examiner's favorite topic for output prediction questions. A static variable is local to a function, but it REFUSES to be destroyed when the function ends. It remembers its value for the next time the function is called.

• Scope: Local to the function.
• Lifetime: Entire runtime of the program.
• Initial Value: EXACTLY Zero (0). No garbage!
• Storage: RAM (Data Segment, not the Stack).

Predict the output of this code:

1. 1.Call 1: `count` is created and set to 0. It increments to 1. Prints '1'. Function ends, but `count` survives in memory.
2. 2.Call 2: The `static int count = 0` line is IGNORED. `count` is currently 1. It increments to 2. Prints '2'.
3. 3.Call 3: `count` is currently 2. Increments to 3. Prints '3'.

Global variables (declared outside of any function) are accessible by everyone. But what if a global variable is defined in `file1.c`, and you want to use it in `file2.c`? You use `extern`.

• Scope: Global (across all linked files).
• Lifetime: Entire runtime of the program.
• Initial Value: Zero (0).
• Storage: RAM (Data Segment).

What happens if a local variable has the exact same name as a global variable?

C looks for variables from the 'inside out'. It checks the current block {}, then the function, then the global scope.

⇒Unit 3 Mastery

• Can you explain the difference between a Parameter and an Argument?
• Can you draw the memory diagrams showing why Call-by-Value swapping fails?
• Can you trace a recursive function call stack step-by-step down to the base case?
• Do you know the default initial value of an 'auto' variable vs a 'static' variable?
• Can you predict the output of a loop containing a static variable?
• Do you understand the shadowing rules between local and global variables?