5 Functions

The role of functions

Functions package a focused operation behind a name. A typical C++ function has a return type, a name, a parameter list, and a body. For example, a function named square could accept an integer parameter, multiply that value by itself, and return the result.

A function call transfers control to the function. The function executes its body and then returns control to the caller, optionally carrying a result. A meaningful name, explicit inputs, and a clear result or side effect make a function easier to understand and use.

Takeaway: Treat each function as a small operation with a clear purpose, clear inputs, and a clear outcome.

Declaring and defining functions

A Function declaration tells the compiler that a function exists. It gives the function's return type, name, and parameter types, but it does not provide the implementation. A declaration is also called a prototype. For example, int square(int number); declares a function without defining its body.

A Function definition includes the function body and describes what the function does. For example, a definition of square can return number * number. The declaration and definition must describe the same function: their return type and parameter types must agree.

The declaration must be visible before a call that uses the function. Therefore, a program can place a declaration before main and the definition later, or it can place the complete definition before the call. In a multi-file program, declarations commonly belong in a header file while definitions belong in a source file. This separates the interface, or how a function is used, from the implementation, or how it works.

Takeaway: Declare a function before code calls it, and keep its declaration and definition consistent.

Parameters and arguments

A parameter is a variable listed in a function declaration or definition. An argument is the value supplied at the call site. In add(4, 7), the values 4 and 7 are arguments; they initialize the function's corresponding parameters.

The parameter list determines how many arguments a function accepts and what types those arguments should have. An empty parameter list represents a function that takes no arguments. In a declaration, a parameter name may be omitted when only the type is needed, as in int square(int);.

For example, a function that adds two integers can use parameters named first and second, while a call supplies two integer arguments. The names of parameters are local to the function and help explain the role of each input.

Takeaway: Parameters describe a function's inputs; arguments provide the values for those inputs.

Return values and void functions

The return type appears before the function name. A non-void function must return a suitable value on every path that reaches the end of the function. A void function performs an operation without returning a value.

A return statement transfers control back to the caller. When it includes an expression, that expression provides the result of the function call. A void function can use return; to leave early without producing a value.

For example, a function that computes half of an integer can use the return type double and return a floating-point result. A function that prints a message can use void. Simply evaluating an expression is not enough for a non-void function; the result must be returned explicitly.

Takeaway: Match the return statement to the return type, and make sure every required execution path produces a result.

Scope and local data

Scope is the region in which a name can be used. Function parameters and local variables are available inside their function, while a variable declared inside a nested block is available only within that block and its nested regions.

For example, parameters named a and b and a local variable named result inside difference cannot normally be used in main or in another function. A variable declared inside an if block is no longer in scope after that block ends.

An inner declaration can hide a name from an enclosing scope. Although this is allowed, distinct names are usually clearer. Passing data through parameters is generally preferable to relying heavily on global variables because it makes a function's inputs explicit and reduces unintended interactions.

Takeaway: Keep data near the code that uses it, and make communication between functions explicit through parameters and return values.

Pass-by-value

Pass-by-value means that a function receives its own parameter object initialized from the argument. If the function assigns a new value to that parameter, the caller's original variable is unchanged.

For example, if try_to_change receives an integer and assigns 99 to its parameter, the integer variable supplied by the caller keeps its original value. This behavior is useful when the function should work with an independent copy or when the value is small, such as an int, double, or char.

Passing a class object by value also gives the function a separate object and may involve copying or moving. When a later design needs to avoid copying a large object without modifying it, a reference-to-const parameter can be used; that is different from pass-by-value because it refers to the caller's object.

Takeaway: Changing a by-value parameter changes only the function's local copy.

Function overloading

Function overloading lets multiple functions in the same scope use one name when their parameter lists differ. The differences may involve parameter types or the number of parameters. For example, maximum can have one version for two int arguments and another for two double arguments.

When a call is made, the compiler considers the available candidates and chooses the best match based on argument count, types, and permitted conversions. If no single best match exists, the call is ambiguous and the program is ill-formed.

Return types alone cannot distinguish overloads. Two functions with identical parameter lists cannot be overloaded merely because one returns int and the other returns double. Overloads are clearest when they represent the same conceptual operation.

Takeaway: Use overloads for related operations, and distinguish them through parameter lists rather than return types.

Program decomposition and design

Program decomposition divides a larger task into smaller functions with focused responsibilities. A rectangle-area program, for example, can use one function to read a length, another to calculate the area, and another to print the result, while main coordinates the sequence.

This organization reduces complexity because each function can be understood independently. It also encourages reuse, makes individual operations easier to test with known inputs, localizes changes, and clarifies how components communicate through interfaces.

A well-designed function usually has a meaningful name, a small and coherent responsibility, explicit inputs, and a clear result or side effect. Avoid unnecessary dependence on global state so that the function remains predictable and reusable.

Takeaway: Separate input, computation, output, and coordination when doing so gives each function one clear responsibility.

Common mistakes and a review checklist

Several mistakes recur when writing functions:

• Calling a function before a declaration is visible. Place a declaration before the call or move the definition earlier.

• Mismatching a declaration and definition. Check that the return type and every parameter type agree.

• Computing an expression without returning it from a non-void function. Use an explicit return statement.

• Expecting pass-by-value to modify the caller's variable. A by-value parameter is a separate object.

• Trying to overload functions using only their return types. Overloads require different parameter lists.

• Giving one function too many unrelated responsibilities. Split the work when separate operations can be named and tested independently.

A useful review sequence is to check visibility first, then compare the declaration with the definition, then verify parameter and argument types, return behavior, scope, and the function's responsibility.

Takeaway: Most function errors become easier to find when interfaces, data flow, and responsibilities are checked separately.