# Lecture 7: Declare, define, and call functions ## Declarations, definitions, parameters, and return values **Instructor:** [Dr. Debasish Pattanayak](https://drdebmath.github.io)

## A function owns one clear responsibility. · Travel estimate behind a function interface The caller validates input, then a small function receives two values and returns one calculated result. ~~~cpp #include <iostream> double estimateTravel(double distanceKm, double speedKmph) { return distanceKm / speedKmph; } int main() { double distance = 420; double speed = 70; if (distance >= 0 && speed > 0) std::cout << "Travel time: " << estimateTravel(distance, speed) << " hours"; } ~~~ **Takeaways** - A function owns one clear responsibility. - Parameters receive the arguments passed by the caller. - The return value is the calculated output.

## The general form of a declaration, a definition, and a call ~~~cpp <return type> <name>(<parameter type> <parameter>, ...); // declaration (prototype) <return type> <name>(<parameter type> <parameter>, ...) { // definition: the body return <expression>; // type must convert to <return type> } <name>(<argument>, ...) // call: arguments are copied into the parameters auto <name> = [](<parameter type> <parameter>) { return <expression>; }; // lambda ~~~ | Part | Meaning | | --- | --- | | `<return type>` | The type handed back to the caller. <code>void</code> returns nothing, so its <code>return;</code> carries no value. | | `<name>(<parameters>)` | The signature. Name plus parameter list is what a caller has to match. | | declaration vs definition | A declaration ends at the semicolon and may repeat; exactly one definition supplies the body. | | `<argument>` | Copied into the parameter, so assigning to the parameter leaves the caller's variable unchanged. | Put the declaration above <code>main</code> whenever the definition sits below it: the compiler must see the declaration before the first call.

## One function performs one explainable operation A function's specification states: - its parameters and their types; - any preconditions the caller must satisfy; - its return value or visible effect. Small, clearly specified functions reduce duplication and can be tested independently.

## Read a function’s declaration before its definition ~~~cpp double rectangleArea(double length, double width) { return length * width; } ~~~ Return type → name → parameters → body.

## The function is asked to do "something useful" <figure class="course-meme-figure"> <img src="assets/lecture-memes/l07/function-contract.png" alt="A student hands a small sealed service booth its required inputs and receives one clearly defined result while a rule card keeps the promise visible — visual point: A specification is how "something useful" becomes testable behavior." width="900" height="506" loading="lazy"> <figcaption> <p class="course-meme-setup"><strong>Setup</strong> The function is asked to do "something useful."</p> <p class="course-meme-punchline"><strong>Punchline</strong> A specification is how "something useful" becomes testable behavior.</p> </figcaption> </figure>

## Declare interfaces once and define each function once ~~~cpp #include <iostream> double rectangleArea(double length, double width); // declaration int main() { std::cout << rectangleArea(4.0, 3.0); } double rectangleArea(double length, double width) { return length * width; } ~~~

## Quick check: What does this line do? <span class="course-extra-kicker">📊 Head to sli.do — event code 2032157</span> ~~~cpp double rectangleArea(double length, double width); ~~~ - **A)** Defines the function with an empty body - **B)** Calls the function with default arguments - **C)** Declares a prototype so callers can use it before the definition - **D)** Causes an error — a body is required

## Value parameters isolate small inputs as local copies ~~~cpp int doubled(int value) { value *= 2; return value; } ~~~ Changing <code>value</code> does not change the caller's argument.

## A signature is a tiny sentence, if you read it in order <figure class="course-meme-figure"> <img src="assets/lecture-memes/l07/read-signature.png" alt="A student reads a function blueprint from left to right: result slot, name badge, input slots, and a workroom — visual point: Read the grammar left to right before opening the body." width="900" height="506" loading="lazy"> <figcaption> <p class="course-meme-setup"><strong>Setup</strong> Four stations sit in a row: result, name, inputs, workroom.</p> <p class="course-meme-punchline"><strong>Punchline</strong> Read the grammar left to right before opening the body.</p> </figcaption> </figure>

## Game evolution: A scoring function makes progress measurable | Today's concept | Exact game part enabled | |---|---| | functions and value parameters | award points for cleaning without changing the caller accidentally | ~~~cpp #include <iostream> int scoreAfterClean(int score, bool dirtHere) { if (dirtHere) score += 10; return score; } int main() { int score=0; std::cout << scoreAfterClean(score,true) << ' ' << score << '\n'; } ~~~ **Test:** the function returns 10, while the caller's original <code>score</code> remains 0. **Next unlock · L08:** deliberately mutate row and column through references.

## Quick check: What is printed? <span class="course-extra-kicker">📊 Head to sli.do — event code 2032157</span> ~~~cpp int doubled(int v){ v*=2; return v; } int main(){ int x=5; doubled(x); cout<<x; } ~~~ - **A)** 10 - **B)** 5 - **C)** 20 - **D)** Compilation error

## Named functions turn a calculation into testable steps ~~~cpp double subtotal(double price, int count) { return price * count; } double tax(double amount, double rate) { return amount * rate; } double total(double amount, double rate) { return amount + tax(amount, rate); } ~~~ Each name states one responsibility.

## A lambda packages short callable behavior where it is used A lambda expression defines a small callable at its point of use. ~~~cpp auto isPositive = [](int value) { return value > 0; }; ~~~ Named functions remain the default for novice code. Lambdas return later as search and sorting applications.

## The caller arrives before the body is finished <figure class="course-meme-figure"> <img src="assets/lecture-memes/l07/declaration-definition.png" alt="A small signpost announces a service before the service room is built, allowing a caller to walk to the promised location — visual point: A declaration says "this service exists"; the definition does the work later." width="900" height="506" loading="lazy"> <figcaption> <p class="course-meme-setup"><strong>Setup</strong> The caller arrives before the function body is finished.</p> <p class="course-meme-punchline"><strong>Punchline</strong> A declaration says "this service exists"; the definition does the work later.</p> </figcaption> </figure>

## Clear declarations and specifications make behavior testable - A function's specification states its parameters, preconditions, and return value. - A declaration makes a function known before its definition. - Value parameters are copies. - Prefer short functions with one explainable responsibility.

## Verify Travel estimate behind a function interface with a claim, trace, boundary, and improvement Use the practical example as a small experiment. Before you leave, make the reasoning visible: - **Claim:** A function owns one clear responsibility. - **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 returns the area of a rectangle. - Write a function that converts Celsius to Fahrenheit. - Write a boolean function that reports whether an integer is even.

## Explain Travel estimate behind a function interface 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 Travel estimate behind a function interface **IC151 lab practice · 5 problems** 1. Write a function that returns the area of a rectangle. 1. Write a function that converts Celsius to Fahrenheit. 1. Write a boolean function that reports whether an integer is even. 1. Refactor a unit converter so each conversion is a separate function. 1. State the inputs, output, and precondition of a safe division function. Reaching this set marks the lecture as studied in this browser. [Open the IC151 lab setup and batch schedule](ic151.html).

## Quick check: Spot the design smell <span class="course-extra-kicker">📊 Head to sli.do — event code 2032157</span> You explain your function as: "It computes the tax, and then it also prints the receipt." What does this signal about the design? - **A)** Good design — related work is bundled together - **B)** Split it — the function mixes two responsibilities - **C)** Add a bool parameter to toggle the printing - **D)** Convert the function to a lambda

## Did you know? - The `a` in `a.out` stands for assembler output, a name kept from the very first Unix in 1971. - GCC stands for GNU Compiler Collection, started by Richard Stallman in 1987; `g++` is its C++ front end. - C++ received its first ISO standard in 1998. C++11, C++14 and C++17 followed, and C++17 is the version this course assumes.

## Stop one growing main function from mixing movement, sensing, and display. **Studio thread:** Give robot actions clear interfaces | Ask | Today’s answer | |---|---| | **Problem** | Stop one growing main function from mixing movement, sensing, and display. | | **Model** | The controller coordinates small operations with explicit responsibilities. | | **Represent** | Function parameters are inputs; return values report results. | | **Solve** | Decompose by one explainable task and compose calls into a controller. | | **Verify** | Test each function independently before integrating them. | | **Improve** | Remove duplication and rename a function whose description needs “and”. | **Technique lens:** procedural decomposition **Compare:** one monolithic procedure versus several testable functions