C++ Programming Functions Syllabus

On what parameter differences can functions be overloaded?

On the number of parameters, the types of parameters, and the order of parameter types. They cannot be overloaded solely on the basis of differing return types or by making a parameter const-by-value.

Why can't two functions be overloaded when they differ only in return type?

Because the return type is not part of the function signature. The compiler resolves overloads using the arguments at the call site, which do not convey the expected return type, so it could not disambiguate the calls.

What is overload resolution?

The compile-time process by which the compiler examines the arguments of a call and selects the best-matching overloaded function, considering exact matches, promotions, standard conversions, and user-defined conversions.

What is an ambiguous call in overload resolution, and what is the result?

When two or more overloads are equally good matches for the given arguments (no single best match), the call is ambiguous. The compiler reports a compile-time error.

Can const-ness of a reference/pointer parameter be used to overload functions? Give an example.

Yes. void f(int&) and void f(const int&) are distinct overloads, as are void f(int*) and void f(const int*). A const lvalue argument selects the const version. (Note: top-level const on by-value parameters, like int vs const int, does NOT distinguish overloads.)

What is a default argument in C++?

A value specified in the function declaration that is automatically used for a parameter when the caller omits the corresponding argument, e.g. void greet(std::string name = "World");

What is the rule about the position of default arguments in a parameter list?

Default arguments must be the trailing (rightmost) parameters. Once a parameter has a default, all parameters to its right must also have defaults.

Where should default arguments be specified when a function is both declared and defined separately?

They should be given in the declaration (typically in the header), not repeated in the definition. Specifying the same default in both places is an error; the caller only sees the declaration.

How can default arguments sometimes replace function overloading?

A single function with default arguments can serve callers who pass different numbers of arguments, e.g. int box(int l, int w = 1, int h = 1); handles box(l), box(l,w), and box(l,w,h) without writing three overloads.

What is a potential conflict between default arguments and function overloading?

They can create ambiguity: if an overload can be called with fewer arguments due to defaults, and another overload matches that same call, the compiler cannot decide, producing an ambiguous-call error.

Define recursion in the context of functions.

Recursion is a technique where a function calls itself, directly or indirectly, to solve a problem by breaking it into smaller subproblems of the same form.

What two essential components must every correct recursive function have?

A base case (terminating condition that stops the recursion) and a recursive case (the function calling itself on a smaller/simpler input that progresses toward the base case).

What happens if a recursive function has no reachable base case?

It recurses infinitely, consuming stack frames until the call stack is exhausted, causing a stack overflow (and program crash).

Write a recursive definition of factorial and its base case.

$$n! = \begin{cases} 1 & n = 0 \\ n \times (n-1)! & n > 0 \end{cases}$$ Base case: $0! = 1$; recursive case multiplies $n$ by the factorial of $n-1$.

What is the time complexity of the naive recursive Fibonacci that computes $F(n)=F(n-1)+F(n-2)$?

Exponential time, $O(\varphi^{n})$ where $\varphi = \frac{1+\sqrt{5}}{2}$ (commonly stated as $O(2^{n})$), because it recomputes the same subproblems repeatedly. Space is $O(n)$ for the call stack.

What is the difference between direct and indirect recursion?

Direct recursion: a function calls itself directly (f calls f). Indirect (mutual) recursion: a function calls another function that eventually calls the first back (f calls g, and g calls f).

What is tail recursion?

A recursive call that is the very last operation performed in the function, with nothing left to do after it returns. Compilers can optimize it into a loop (tail-call optimization), using constant stack space.

Compare recursion and iteration in terms of memory usage.

Iteration uses a fixed amount of stack space (typically one frame). Recursion allocates a new stack frame for each call, so it uses O(depth) stack memory and risks stack overflow for deep recursion.

What is the recurrence relation form used to analyze many recursive algorithms via the Master Theorem?

$$T(n) = a\,T\!\left(\frac{n}{b}\right) + f(n)$$ where $a$ is the number of subproblems, $\frac{n}{b}$ is the subproblem size, and $f(n)$ is the non-recursive work per call.

What is a recursive function's 'depth of recursion' and why does it matter?

The maximum number of nested active calls before a base case returns. It matters because each level consumes a stack frame; excessive depth causes stack overflow, and it determines the space complexity O(depth).

What is the scope and lifetime of a local variable declared inside a function?

Scope: local to the function (block scope) — visible only within it. Lifetime: automatic storage duration — created when the function is entered and destroyed when it returns (unless declared static).

What does declaring a local variable static inside a function do?

It gives the variable static storage duration: it is initialized once and retains its value between successive calls to the function, while still being visible only within that function's scope.

What is a function pointer and how do you declare one that points to int f(int)?

A function pointer stores the address of a function. Declaration: int (*fp)(int); It can be assigned fp = f; and called as fp(5) or (*fp)(5).

What is a function template and how does it relate to overloading?

A function template defines a family of functions parameterized by type, e.g. template<typename T> T max(T a, T b). The compiler instantiates a concrete function per type used, providing type-safe generic code instead of writing separate overloads for each type.

What is the special role of the main function's return value in C++?

main returns an int that is the program's exit status to the operating system: 0 (or EXIT_SUCCESS) signals success, non-zero signals failure. If no return statement is present, main implicitly returns 0.

What is a constexpr function and what does it enable?

A constexpr function is one that can be evaluated at compile time when given constant-expression arguments, e.g. constexpr int square(int x){ return x*x; }. It enables its result to be used in contexts requiring compile-time constants, such as array sizes.

What is recursion's typical trade-off versus iteration for problems like tree traversal?

Recursion offers cleaner, more readable code that closely mirrors the recursive structure of the problem (e.g. trees), at the cost of function-call overhead and stack memory. Iteration is generally faster and uses less memory but can be more complex to write for inherently recursive structures.

Can inline and recursion be combined effectively?

Generally no. Compilers typically will not fully inline a recursive function because the depth of recursion is unknown at compile time, so the inline request is usually ignored for the recursive calls.

What is the difference between an lvalue reference parameter (T&) and an rvalue reference parameter (T&&)?

T& binds to modifiable lvalues (named objects). T&& binds to rvalues (temporaries), enabling move semantics and perfect forwarding. Overloading f(T&) and f(T&&) lets a function behave differently for lvalue vs rvalue arguments.

How does the compiler pass control and data during a function call at runtime (the call mechanism)?

A stack frame (activation record) is pushed containing the return address, the arguments, and space for local variables. Control jumps to the function; on return, the return value is delivered, the frame is popped, and execution resumes at the return address in the caller.