# Lecture 8: Choose copy, alias, and recursion deliberately ## References, overloading, decomposition, and the call stack **Instructor:** [Dr. Debasish Pattanayak](https://drdebmath.github.io)

## Parameter roles are visible at the interface. · Return two results without global variables Input parameters are passed by value; output parameters are passed by reference and name the caller’s existing variables. The function declaration makes both roles explicit. ~~~cpp #include <iostream> void orderPair(int first, int second, int& smaller, int& larger) { if (first <= second) { smaller = first; larger = second; } else { smaller = second; larger = first; } } int main() { int low = 0, high = 0; orderPair(17, 4, low, high); std::cout << low << " " << high << '\n'; } ~~~ **Takeaways** - Parameter roles are visible at the interface. - Reference parameters avoid hidden global variables. - One function performs one testable job.

## The general form of the three parameter-passing mechanisms and an overload set ~~~cpp void <name>(<T> <p>); // by value: the function works on a copy void <name>(<T>& <p>); // by reference: the function shares the caller's object void <name>(const <T>& <p>); // by const reference: shared, read-only, not copied <return type> <name>(<T> <p>, <U> <q> = <default>); // trailing default argument void <name>(<T>); // an overload set: one name, void <name>(<T>, <U>); // distinguished only by the parameter lists ~~~ | Part | Meaning | | --- | --- | | `<T> <p>` | A copy. Changes stay inside the function; safe, but costs a copy. | | `<T>& <p>` | An alias for the caller's object. Writes are visible outside, so the caller must expect them. | | `const <T>& <p>` | No copy and no mutation. The default for anything large you only need to read. | | `= <default>` | Defaults must be trailing, and are written on the declaration only, never repeated on the definition. | | overloading | Parameter lists must differ. A different return type alone is not enough and will not compile. | Choose the parameter-passing mechanism from what the function does with the argument: pass by value for a small input, by <code>const</code> reference to read only, and by reference only when the caller expects the argument to be modified.

## The parameter declaration decides copy, alias, or read-only access ~~~cpp void clampToZero(double& value) { if (value < 0.0) value = 0.0; } ~~~ A reference is another name for the caller's object. Modifying the argument must be part of the function's specification.

## const reference reads without copying or mutating ~~~cpp void printReading(const double& reading) { std::cout << reading << '\n'; } ~~~ The syntax matters now; avoiding expensive copies becomes useful when records and strings arrive.

## Quick check: What is printed? <span class="course-extra-kicker">📊 Head to sli.do — event code 2032157</span> ~~~cpp void bump(int& value) { value += 1; } int main() { int x = 5; bump(x); std::cout << x; } ~~~ - **A)** 5 - **B)** 6 - **C)** Compile error - **D)** Undefined behavior

## The caller sends a value into a function — then what? <figure class="course-meme-figure"> <img src="assets/lecture-memes/l08/reference-alias.png" alt="A function helper reaches through an alias rope to adjust the same object held by the caller, while separate copies stay untouched — visual point: Copy it for a souvenir; alias it if you mean to change the original." width="900" height="506" loading="lazy"> <figcaption> <p class="course-meme-setup"><strong>Setup</strong> The caller sends a value into a function.</p> <p class="course-meme-punchline"><strong>Punchline</strong> Copy it for a souvenir; alias it if you mean to change the original.</p> </figcaption> </figure>

## Overloads share a name only when parameter lists distinguish them ~~~cpp int absolute(int value); double absolute(double value); ~~~ The compiler selects from parameter lists. Return type alone cannot distinguish overloads.

## Game evolution: A movement function isolates one rule | Today's concept | Exact game part enabled | |---|---| | reference parameters and decomposition | update the caller's two coordinate variables in one named operation | ~~~cpp void movePlayer(int& row, int& column, int dRow, int dColumn) { row += dRow; column += dColumn; } int main() { int row=2, column=3; movePlayer(row,column,0,1); } ~~~ **Parameter passing:** <code>row</code> and <code>column</code> are passed by reference; the direction values are passed by value. **Next unlock · L09:** store the complete Snake body as sequences of coordinates.

## Quick check: Which second declaration overloads absolute legally? <span class="course-extra-kicker">📊 Head to sli.do — event code 2032157</span> ~~~cpp int absolute(int value); // already declared ~~~ - **A)** `double absolute(int value);` — a different return type - **B)** `int absolute(double value);` — a different parameter list - **C)** `int absolute(int number);` — a different parameter name - **D)** Any of these

## Decomposition keeps main readable and each step testable ~~~cpp double readPositive(); double calculateFare(double distance, double rate); void printFare(double fare); ~~~ <code>main</code> coordinates these tasks instead of containing every detail.

## The function needs to look, not rearrange <figure class="course-meme-figure"> <img src="assets/lecture-memes/l08/const-reference.png" alt="A function helper examines a shared object through a glass window while the object stays unchanged and no duplicate is made — visual point: "Hands off, I am only reading" — no copy, no touch." width="900" height="506" loading="lazy"> <figcaption> <p class="course-meme-setup"><strong>Setup</strong> The function needs to look, not rearrange.</p> <p class="course-meme-punchline"><strong>Punchline</strong> "Hands off, I am only reading" — no copy, no touch.</p> </figcaption> </figure>

## Each active call owns a stack frame until it returns Each active call has a stack frame containing parameters, local variables, and the return address. The most recent unfinished call completes first—last in, first out.

## Recursion needs a base case and a smaller next call ~~~cpp int factorial(int n) { if (n <= 1) return 1; // base case return n * factorial(n - 1); // smaller input } ~~~ Every recursive call must move measurably toward a base case.

## Two functions want the same name badge <figure class="course-meme-figure"> <img src="assets/lecture-memes/l08/overload-signatures.png" alt="Two service doors share one symbol but accept visibly different input shapes; changing only the returned package does not create a third door — visual point: Different inputs earn different doors; a different return alone does not." width="900" height="506" loading="lazy"> <figcaption> <p class="course-meme-setup"><strong>Setup</strong> Two functions want the same name badge.</p> <p class="course-meme-punchline"><strong>Punchline</strong> Different inputs earn different doors; a different return alone does not.</p> </figcaption> </figure>

## Choose parameter passing and decomposition from the specification - References can expose caller state intentionally. - <code>const&</code> provides read-only access through an alias. - Overloads need distinguishable parameter lists. - The call stack tracks unfinished calls. - Recursive design requires a base case and progress.

## Verify Return two results without global variables with a claim, trace, boundary, and improvement Use the practical example as a small experiment. Before you leave, make the reasoning visible: - **Claim:** Parameter roles are visible at the interface. - **Trace:** name the state that changes and the observation that would confirm it. - **Boundary:** choose one smallest, largest, empty, or invalid input that could expose a defect. - **Improvement:** explain one change that would make the solution clearer or safer. ### Exit ticket Choose one problem to solve now and two to attempt in the lab: - Write a function that swaps two integers through references. - Overload absoluteValue for int and double. - Split a bill calculator into input, calculation, and output functions.

## Explain Return two results without global variables without opening the code Explain today’s idea to a partner without opening the code: 1. State the input, output, and one rule the solution must preserve. 2. Point to the operation that makes progress or changes the state. 3. Name the first test you would run after changing the implementation. If the explanation needs “and then another unrelated thing,” split the design before you code.

## Solve five problems to transfer Return two results without global variables **IC151 lab practice · 5 problems** 1. Write a function that swaps two integers through references. 1. Overload absoluteValue for int and double. 1. Split a bill calculator into input, calculation, and output functions. 1. Compare a large read-only parameter by value and const reference. 1. Write factorial recursively and identify its base case. Reaching this set marks the lecture as studied in this browser. [Open the IC151 lab setup and batch schedule](ic151.html).

## Quick check: Which call returns first? <span class="course-extra-kicker">📊 Head to sli.do — event code 2032157</span> ~~~cpp int factorial(int n) { if (n <= 1) return 1; // base case return n * factorial(n - 1); } int main() { factorial(3); } ~~~ - **A)** factorial(3) — it was called first - **B)** factorial(1) — last in, first out - **C)** factorial(2) — the middle call - **D)** They all return together

## Did you know? - Each call owns a stack frame, so a recursion that never reaches its base case ends in a stack overflow, the phrase the programmers' question-and-answer site adopted as its name in 2008. - References and function overloading were among the first features that "C with Classes" added to C in the early 1980s. - The classic joke: to understand recursion, you must first understand recursion.

## Let functions observe or intentionally change shared robot state. **Studio thread:** Build a testable controller | Ask | Today’s answer | |---|---| | **Problem** | Let functions observe or intentionally change shared robot state. | | **Model** | Calls form a stack of unfinished responsibilities. | | **Represent** | Small inputs are passed by value; shared state is passed by reference; a const reference gives read-only access. | | **Solve** | Choose a parameter-passing mechanism from the specification, not from syntax preference. | | **Verify** | Trace caller and callee state, including a recursive countdown preview. | | **Improve** | Return information instead of mutating when either design is equally clear. | **Technique lens:** decomposition with controlled aliasing **Compare:** returning a new state versus updating through a reference