05 Functions

Function declaration and Function definition

A function is a named block of C++ statements that performs a specific task. Breaking a program into functions makes its parts easier to reuse, test, and understand.

A Function declaration tells the compiler a function's name, return type, and parameter types, but it does not contain the body. For example, int add(int first, int second); introduces a function that returns an integer and accepts two integer parameters.

A Function definition provides the implementation. The declaration and definition must agree about the function name, return type, and parameter types. A declaration can appear before a definition, so main can call a function whose implementation appears later.

The general structure is a return type, a function name, a parameter list, and a body. A function with return type void performs an action without returning a value. It may use return; to leave the function early, but it cannot return a value.

Takeaway: A declaration announces what a function looks like; a definition explains how it works.

Parameters, arguments, and return values

A parameter is the variable named in a function's declaration or definition. An argument is the actual value supplied by a call. For a multiplication function with parameters named x and y, a call such as multiply(4, 6) supplies two arguments.

By default, C++ passes parameters by value. The function receives copies, so changing a parameter does not change the caller's original variable. A reference parameter, written with &, can allow the function to modify that original variable. A const reference can avoid a copy while preventing modification.

The return value is the result sent from a function to its caller. A function returning a non-void type should provide a compatible value along every possible execution path. A returned value can be stored, printed, or used as part of another function call.

Function calls transfer execution to the called function. Its parameters are initialized, its body runs, and control then returns to the statement after the call. Calls may be nested: the inner call finishes first, and its result becomes an argument for the outer call.

Returning a local variable by value is safe because the value is copied or moved to the caller. Returning a pointer or reference to a local variable is invalid because that local object no longer exists after the function ends.

Takeaway: Parameters receive information, arguments provide it, and a return value communicates a result back to the caller.

Scope and local variables

The scope of a name is the part of the program where that name can be used. A variable declared inside a function or block is usually a local variable. Its scope begins at its declaration and ends at the end of its enclosing block.

Function parameters are available throughout the function body. A variable declared inside an inner block is unavailable after that block ends. An inner declaration can also hide a name from an outer scope; this is called shadowing. Although shadowing is legal, descriptive and distinct names generally make programs clearer.

Ordinary local variables are independent between function calls. If a function creates a local counter, increments it, and prints it, each call normally starts with a new counter. A local variable declared static has a longer lifetime and retains its value between calls, so it should be used deliberately.

Example: A variable named value inside one function is separate from a variable with the same name in another function. The two functions cannot use each other's local variables directly; they must communicate through parameters, return values, or other deliberately shared mechanisms.

Takeaway: Scope controls where names are visible, while lifetime controls how long the associated objects exist.

Function overloading

Function overloading allows several functions in the same scope to share a name when their parameter lists differ. The compiler chooses an overload by comparing the number and types of the supplied arguments, including applicable standard conversions.

For example, one area function might accept an integer side length, while another area function accepts a floating-point radius. A call with an integer argument selects the first overload, whereas a call with a floating-point argument selects the second when the choice is unambiguous.

Overloads may differ in the number of parameters, the parameter types, or the order of parameter types. They cannot differ only by return type. Therefore, declarations such as int getValue(); and double getValue(); do not form valid overloads. If multiple overloads are equally suitable, the call is ambiguous and the program is ill-formed.

Takeaway: Overloading gives one descriptive name several parameter-based interfaces; the return type alone never selects an overload.

Recursion and the call stack

Recursion occurs when a function calls itself. A sound recursive design has a base case that stops the process and a recursive case that handles a smaller or simpler problem.

For a factorial function, the mathematical definition is:

The base case returns one when the input is zero or one. The recursive case returns the input multiplied by a call using an input smaller by one. For an input of four, the calls eventually reach the base case and produce:

Each active call has its own parameters and local variables. These active calls are kept in the call stack. If recursion never reaches its base case, calls continue until the program exhausts available stack space.

Recursion is natural for trees, nested structures, and divide-and-conquer algorithms. For other problems, a loop may be more efficient or easier to control. The complete recursive example can be organized so that main calls a power function, the power function recursively computes the result, and a separate printing function displays it.

Takeaway: Every recursive function needs progress toward a base case, and each call must reduce the remaining problem in a well-defined way.