{"title":"Function Basics","description":null,"content":"A function is a named block of code that performs one job and can be called from anywhere in a program. Functions allow writing a piece of logic once, naming it, and reusing it instead of pasting the same code in five different places. This lesson covers what a function is, the parts that make one up, how to define and call functions that return a value, and how `void` functions differ from those that don't.\n\n---\n\n# Why Functions Exist\n\nConsider an online store program that needs to print a welcome banner in three different places: when the app starts, when a user signs in, and when a guest browses the homepage. Without functions, the same three lines of output code get pasted three times. Fixing a typo means fixing it in every copy. Changing the banner means hunting down every paste.\n\nThe painful version:\n\n\n```cpp\n#include \n\nint main() {\n // App start\n std::cout << \"==========================\" << std::endl;\n std::cout << \" Welcome to ShopMaster!\" << std::endl;\n std::cout << \"==========================\" << std::endl;\n\n // Pretend the user signs in here\n std::cout << \"==========================\" << std::endl;\n std::cout << \" Welcome to ShopMaster!\" << std::endl;\n std::cout << \"==========================\" << std::endl;\n\n // Pretend a guest visits the homepage here\n std::cout << \"==========================\" << std::endl;\n std::cout << \" Welcome to ShopMaster!\" << std::endl;\n std::cout << \"==========================\" << std::endl;\n\n return 0;\n}\n```\n\n\nNine lines of output code, three identical copies of the same three lines. The compiler doesn't care, but a human reader has to scan all of it, and any change to the banner requires editing three places.\n\nA function fixes that. Wrap the three lines once, give them a name, and call the name three times:\n\n\n```cpp\n#include \n\nvoid printWelcome() {\n std::cout << \"==========================\" << std::endl;\n std::cout << \" Welcome to ShopMaster!\" << std::endl;\n std::cout << \"==========================\" << std::endl;\n}\n\nint main() {\n printWelcome();\n printWelcome();\n printWelcome();\n return 0;\n}\n```\n\n\nSame result, but the banner text lives in one place. Fixing it once fixes it everywhere. That principle has a name: **DRY**, which stands for \"Don't Repeat Yourself.\" Functions are the most common tool for following it.\n\nFunctions also help with **decomposition**. A program that does a hundred different things is hard to read as one giant `main`. Split into ten functions of ten things each, the program becomes a series of named steps, and each step can be read independently.\n\n---\n\n# Anatomy of a Function\n\nEvery function in C++ has the same basic shape. Four parts, in order:\n\n\n```cpp\nreturn_type name(parameters) {\n body\n}\n```\n\n\nEach part has a job:\n\n- **return_type** is the type of value the function hands back to whoever called it. If the function doesn't hand back a value, this is `void`.\n- **name** is what the function is called. Pick something descriptive (`calculateTotal`, not `doStuff`).\n- **parameters** are the inputs the function accepts. The list lives inside parentheses, separated by commas. A function with no inputs has empty parentheses: `()`.\n- **body** is the code inside the braces. It runs when the function is called.\n\nThe first line (everything before the opening brace) is the **function header**. The braces and what's between them are the **function body**.\n\nA function that adds two prices and gives back the sum:\n\n\n```cpp\ndouble addPrices(double a, double b) {\n double sum = a + b;\n return sum;\n}\n```\n\n\nReading the header: return type is `double`, name is `addPrices`, it takes two `double` parameters called `a` and `b`. The body computes `a + b` and uses `return` to hand the result back.\n\nThis lesson uses simple parameter lists in examples, but the focus is on the function as a whole, not the parameter mechanics.\n\n\n```mermaid\nflowchart LR\n A[Return Type
double]:::cyan --> B[Name
addPrices]:::orange\n B --> C[Parameters
double a, double b]:::teal\n C --> D[Body
compute and return]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe diagram shows the four pieces of the function definition lined up. A function header reads left to right: type, name, inputs, then the body in braces.\n\n---\n\n# Defining vs Calling a Function\n\nTwo separate actions involve a function: **defining** it (writing the body once), and **calling** it (running it from somewhere else). These often get mixed up because the syntax looks related but is different.\n\nA definition has braces and a body:\n\n\n```cpp\nvoid displayCart() {\n std::cout << \"Your cart is empty.\" << std::endl;\n}\n```\n\n\nA call has parentheses and a semicolon:\n\n\n```cpp\ndisplayCart();\n```\n\n\nThe call is what actually runs the code. The definition describes what the code is. A function can be defined once and called as many times as needed.\n\n\n```cpp\n#include \n\nvoid displayCart() {\n std::cout << \"Your cart is empty.\" << std::endl;\n}\n\nint main() {\n std::cout << \"Checking cart...\" << std::endl;\n displayCart();\n std::cout << \"Checking again...\" << std::endl;\n displayCart();\n return 0;\n}\n```\n\n\nTwo calls, one definition. The body of `displayCart` runs twice, once per call.\n\nThe order of code on the page matters. C++ reads the file top to bottom, and a function must be visible to the compiler at the point where it's called. The simple way to handle this is to define helper functions above `main`, the same way the examples in this lesson do. For now, \"define above the caller\" works.\n\n\n```mermaid\nflowchart TD\n A[Definition
void displayCart curly braces body]:::cyan --> B[Compiler reads file
top to bottom]:::orange\n B --> C[Call
displayCart semicolon]:::teal\n C --> D[Body runs]:::green\n C --> E[Body runs again]:::green\n C --> F[Body runs again]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe diagram captures the relationship: one definition, many calls. Each call jumps into the body, runs it, then comes back to the line after the call.\n\n---\n\n# The Call Site\n\nThe line that calls a function is the **call site**. It looks like the function's name followed by parentheses. Empty parentheses if the function takes no inputs, comma-separated values if it does. The semicolon at the end makes the call a statement.\n\n\n```cpp\nprintWelcome(); // call site, no inputs\ndisplayCart(); // call site, no inputs\naddPrices(9.99, 4.50); // call site, two inputs (covered in next lesson)\n```\n\n\nWhen the program hits a call site, three things happen in order:\n\n1. The program pauses whatever it was doing at that line.\n2. Control jumps into the function's body and runs the body line by line.\n3. When the body finishes (either by reaching the end or hitting a `return`), control jumps back to the line right after the call site.\n\nThat round trip happens fast, but it's important to picture it. A call isn't text on the page; it's an actual jump in the order code runs.\n\n\n```cpp\n#include \n\nvoid shipOrder() {\n std::cout << \" [shipping...]\" << std::endl;\n std::cout << \" [packed and labeled]\" << std::endl;\n}\n\nint main() {\n std::cout << \"Before ship\" << std::endl;\n shipOrder();\n std::cout << \"After ship\" << std::endl;\n return 0;\n}\n```\n\n\nThe `\"Before ship\"` line runs, then the call site jumps into `shipOrder`, the two indented lines run, control jumps back, and `\"After ship\"` runs. The two indented lines aren't physically in `main`, but they show up between the two `main` lines because that's where the call happens.\n\n---\n\n# Functions That Return a Value\n\nA function with a non-`void` return type must hand back a value. The `return` keyword does that. When `return value;` runs, the function ends immediately, and the value gets passed back to the call site.\n\nA function that computes a cart total from a fixed set of prices and returns the sum:\n\n\n```cpp\n#include \n\ndouble calculateTotal() {\n double price1 = 19.99;\n double price2 = 4.49;\n double price3 = 12.00;\n return price1 + price2 + price3;\n}\n\nint main() {\n double total = calculateTotal();\n std::cout << \"Cart total: $\" << total << std::endl;\n return 0;\n}\n```\n\n\nReading the call site: `double total = calculateTotal();` runs `calculateTotal`, gets a `double` back, and stores it in the local variable `total`. The `=` here isn't comparison or even regular assignment; it's the syntax for \"store the function's return value in this variable.\"\n\nStoring the return value isn't required. It can be used directly in an expression:\n\n\n```cpp\nstd::cout << \"Cart total: $\" << calculateTotal() << std::endl;\n```\n\n\nOr pass it to another function:\n\n\n```cpp\ndouble doubled = calculateTotal() * 2;\n```\n\n\nThe function call _is_ the value. Anywhere a literal `36.48` would work, `calculateTotal()` works too, and the program runs the function and uses the result in place.\n\nA variation: a function that returns a discount rate based on a fixed cart size.\n\n\n```cpp\n#include \n\ndouble getDiscountRate() {\n int itemsInCart = 7;\n if (itemsInCart >= 5) {\n return 0.10;\n }\n return 0.0;\n}\n\nint main() {\n double rate = getDiscountRate();\n std::cout << \"Discount rate: \" << (rate * 100) << \"%\" << std::endl;\n return 0;\n}\n```\n\n\nTwo `return` statements show up in this function. The first one runs only if the `if` condition is true. If it does run, the function ends right there, and the second `return` never executes. The second `return` only runs when the `if` condition is false.\n\nThat's worth pausing on: `return` is an immediate exit. The function stops, the value is sent back, and nothing else in the body runs.\n\n---\n\n# Functions That Return Nothing: `void`\n\nNot every function needs to give back a value. Some functions exist to do something (print, update, record), not to compute a result. For those, the return type is `void`, C++'s way of saying \"this function returns nothing.\"\n\n\n```cpp\n#include \n\nvoid displayCart() {\n std::cout << \"------ Your Cart ------\" << std::endl;\n std::cout << \"1 x Wireless Mouse $24.99\" << std::endl;\n std::cout << \"2 x USB Cable $8.50\" << std::endl;\n std::cout << \"-----------------------\" << std::endl;\n}\n\nint main() {\n displayCart();\n return 0;\n}\n```\n\n\n`displayCart` doesn't compute anything to capture in a variable. It writes to the screen and that's it. The return type is `void`, the body has no `return value;` line (because there's no value to return), and the call site doesn't store anything: just `displayCart();` on its own line.\n\nTrying to use a `void` function as if it returned a value is a compile error:\n\n\n```cpp\ndouble total = displayCart(); // error: void value not ignored as it ought to be\n```\n\n\n`g++` reports something like:\n\n\n```shell\nerror: void value not ignored as it ought to be\n```\n\n\nThe compiler reports that `displayCart` doesn't produce a value, so `total = displayCart()` doesn't make sense.\n\nThe two flavors line up like this:\n\n\n| Aspect | Value-returning function | `void` function |\n|--------|--------------------------|-----------------|\n| Return type | `int`, `double`, `bool`, `std::string`, etc. | `void` |\n| Must use `return value;`? | Yes, on every path | No (optional bare `return;`) |\n| Can be used in an expression? | Yes (`double t = calculateTotal();`) | No (call is a statement, not a value) |\n| Typical job | Compute and hand back a result | Perform an action with a side effect |\n\n\nThe \"side effect\" wording is worth unpacking. A side effect is anything the function does besides handing back a value: printing to the screen, modifying a global, writing to a file. A `void` function exists for its side effects. A value-returning function can also have side effects, but its main contribution is the return value.\n\n---\n\n# The `return` Statement in Depth\n\n`return` does two things at the same time: it exits the function immediately, and (for non-`void` functions) it carries a value back to the caller.\n\nThe basic shape:\n\n\n```cpp\nreturn expression; // for non-void functions\nreturn; // for void functions, optional\n```\n\n\nA non-`void` function must have a `return value;` statement on every path through the body. \"Every path\" means every possible sequence of branches: the `if` branch, the `else` branch, every `case` of a `switch`. If the compiler can find a way for the function to reach the closing brace without returning, it flags it.\n\n\n```cpp\ndouble getDiscountRate(double subtotal) {\n if (subtotal >= 100.0) {\n return 0.20;\n }\n if (subtotal >= 50.0) {\n return 0.10;\n }\n // Forgot to handle the \"less than 50\" case.\n // g++ warns: control reaches end of non-void function\n}\n```\n\n\n`g++ -Wall` flags this as `warning: control reaches end of non-void function`. The warning is right: if `subtotal` is `30.0`, neither `if` runs, and the function falls off the end without returning anything. The behavior in that case is undefined, which is one of the easier kinds of bug to write and one of the harder to debug. The fix is to add a final `return 0.0;` for the \"no discount\" case:\n\n\n```cpp\ndouble getDiscountRate(double subtotal) {\n if (subtotal >= 100.0) {\n return 0.20;\n }\n if (subtotal >= 50.0) {\n return 0.10;\n }\n return 0.0;\n}\n```\n\n\nNow every path returns a value, and the warning goes away.\n\nFor `void` functions, a `return;` statement (with no value) is optional. It's used to exit early when there's nothing more to do:\n\n\n```cpp\n#include \n\nvoid shipOrder(int itemCount) {\n if (itemCount == 0) {\n std::cout << \"Nothing to ship.\" << std::endl;\n return; // exit early\n }\n\n std::cout << \"Shipping \" << itemCount << \" items.\" << std::endl;\n std::cout << \"Order on its way!\" << std::endl;\n}\n\nint main() {\n shipOrder(0);\n std::cout << \"---\" << std::endl;\n shipOrder(3);\n return 0;\n}\n```\n\n\nThe first call (`shipOrder(0)`) hits the early `return;` and skips the rest of the body. The second call (`shipOrder(3)`) runs the full body. Early returns keep the success path code from being buried inside ever-deeper `if` blocks.\n\nA function can have multiple `return` statements. There's nothing special about that. The first one that runs ends the function. Anything after it in the body doesn't execute.\n\n\n```cpp\ndouble absoluteValue(double x) {\n if (x < 0) {\n return -x;\n }\n return x;\n}\n```\n\n\nTwo returns, one path through each. Clean and easy to read.\n\nDeeper return-type topics like `auto` return types, `[[nodiscard]]`, and returning multiple values via `std::tuple` come up later. For now, the rules are: pick a return type, use `return value;` on every path for non-`void`, use `void` plus optional `return;` for action functions.\n\n---\n\n# `main` is a Function\n\nThe `main` function in every program is itself a regular C++ function. Its header is:\n\n\n```cpp\nint main() {\n // ...\n return 0;\n}\n```\n\n\nThe return type is `int`, the name is `main`, the parameter list is empty (a version takes arguments from the command line). The body runs when the program starts, and the `int` it returns is the program's exit code, where `0` conventionally means success and any non-zero value means some kind of failure.\n\n\n```mermaid\nflowchart LR\n A[OS starts
program]:::cyan --> B[main runs]:::orange\n B --> C[main calls
other functions]:::teal\n C --> B\n B --> D[return 0]:::green\n D --> E[OS reads
exit code]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe diagram shows the lifecycle. The operating system calls `main` to start the program. `main` calls whatever helper functions it needs, then returns an integer to the OS. The OS uses that integer to decide whether the program succeeded.\n\nThere's one tiny exception to the \"every non-`void` function must return a value\" rule, and it's `main` specifically. Omitting `return 0;` at the end of `main` makes the compiler add it implicitly. So these two programs are equivalent:\n\n\n```cpp\nint main() {\n std::cout << \"Hello\" << std::endl;\n return 0;\n}\n```\n\n\n\n```cpp\nint main() {\n std::cout << \"Hello\" << std::endl;\n // implicit return 0; added by the compiler\n}\n```\n\n\nDon't rely on the implicit return in other functions, though. `main` is the only one with this special treatment. In other functions, write the `return` statement explicitly.\n\n---\n\n# Naming Functions\n\nFunction names follow the same rules as variable names: letters, digits, and underscores, no spaces, can't start with a digit. The convention in modern C++ is **camelCase** for functions: lowercase first letter, capitalized first letter of every subsequent word.\n\nGood function names:\n\n\n| Name | What it does |\n|------|--------------|\n| `calculateTotal` | Computes the cart total |\n| `displayCart` | Prints the cart contents |\n| `applyDiscount` | Reduces the price by a discount |\n| `getCustomerName` | Returns the name of the current customer |\n| `isInStock` | Returns `true` if a product is available |\n\n\nNames that work less well:\n\n\n| Name | Problem |\n|------|---------|\n| `doIt` | Does what? |\n| `calc` | Calculate what? |\n| `Total` | Should be lowercase first letter; also, is this a function or a variable? |\n| `function1` | The name says nothing about the job |\n\n\nA good name describes the function's job in a way that lets a reader skip the body. Reading `applyDiscount(cart)` in `main` should give a guess about what it does without scrolling up. Names that need a comment to explain them are almost always too vague.\n\nA useful convention: functions that return a `bool` often start with `is`, `has`, or `should` (like `isInStock`, `hasShipped`, `shouldApplyDiscount`). Calling code reads naturally: `if (isInStock(product)) { ... }`.\n\n---\n\n# A Worked Example: Order Processing\n\nA small program uses several functions together. Each function has one job, and `main` strings them together into an order flow.\n\n\n```cpp\n#include \n\nvoid printWelcome() {\n std::cout << \"======================\" << std::endl;\n std::cout << \" Welcome, valued customer!\" << std::endl;\n std::cout << \"======================\" << std::endl;\n}\n\nvoid displayCart() {\n std::cout << \"Cart contents:\" << std::endl;\n std::cout << \" 1 x Wireless Mouse $24.99\" << std::endl;\n std::cout << \" 2 x USB Cable $8.50\" << std::endl;\n}\n\ndouble calculateSubtotal() {\n double mousePrice = 24.99;\n double cablePrice = 8.50;\n int cableQuantity = 2;\n return mousePrice + (cablePrice * cableQuantity);\n}\n\ndouble getShippingFee() {\n return 4.99;\n}\n\nvoid printReceipt(double subtotal, double shipping) {\n double total = subtotal + shipping;\n std::cout << \"Subtotal: $\" << subtotal << std::endl;\n std::cout << \"Shipping: $\" << shipping << std::endl;\n std::cout << \"Total: $\" << total << std::endl;\n}\n\nint main() {\n printWelcome();\n displayCart();\n\n double subtotal = calculateSubtotal();\n double shipping = getShippingFee();\n printReceipt(subtotal, shipping);\n\n return 0;\n}\n```\n\n\nRead `main` first. It's six lines, and each one is a step in the order flow: greet the customer, show the cart, get the numbers, print the receipt. The program is understandable at that level without reading any of the function bodies.\n\nFor details, drop into each function. `calculateSubtotal` computes the math. `getShippingFee` returns a flat rate. `printReceipt` formats the output. Each function is small enough to fit on a screen, and each has a name that explains its job.\n\nThat layered reading (high-level flow first, details on demand) is the main reason functions exist. A `main` with all the logic inlined would be one big wall of code. Broken into named pieces, the same code becomes a series of steps a new reader can follow.\n\nThe mix of return types: `printWelcome`, `displayCart`, and `printReceipt` are `void` because they only print. `calculateSubtotal` and `getShippingFee` return `double` because their job is to hand back a number. The return type matches the job. That match is most of what picking a return type is about.\n\n---\n\n# Common Mistakes\n\nA few patterns cause issues for beginners. None of them are deep bugs, but each one is annoying enough to watch for.\n\n**Forgetting parentheses on a call.** Without the parentheses, the function isn't called, just named.\n\n\n```cpp\ndouble total = calculateSubtotal; // not a call: total gets a function reference\ndouble total = calculateSubtotal(); // call: total gets the return value\n```\n\n\nThe first line might or might not compile (depending on the function and surrounding code), but it definitely doesn't run the function. The parentheses are what make a call.\n\n**Forgetting the semicolon.** A function call is a statement, so it needs a semicolon. A function definition is a block, so it doesn't (the closing brace is the end).\n\n\n```cpp\n// Definition: no semicolon after the closing brace\nvoid displayCart() {\n std::cout << \"Cart\" << std::endl;\n}\n\n// Call: semicolon required\ndisplayCart();\n```\n\n\n**Using a `void` function's \"return value\".** As shown above, `double t = displayCart();` is a compile error. `void` means there's nothing to use.\n\n**Returning the wrong type.** A function that returns `double` and uses `return \"hello\";` will be rejected by the compiler (or do a confusing implicit conversion in some narrow cases). The type after `return` has to match (or be convertible to) the declared return type.\n\n\n```cpp\ndouble calculateTotal() {\n return \"twenty\"; // error: cannot convert 'const char*' to 'double'\n}\n```\n\n\n**Defining a function inside another function.** C++ does not allow defining a regular function inside the body of another function. This is wrong:\n\n\n```cpp\nint main() {\n void helper() { // error: a function-definition is not allowed here\n std::cout << \"hi\";\n }\n helper();\n return 0;\n}\n```\n\n\nFunctions live at the top level of the file (or inside a class, a topic for the OOP section). Lambdas, which look like inline functions, do exist and are covered later. They're a separate construct with different syntax.","pageType":"cpp"}

Function Basics

Get Premium