Overloading, default arguments and recursion

Overloading: one name, many versions

In C (the older language C++ grew from), every function needs a unique name, so you get abs, labs and fabs. C++ allows overloading: functions with the same name but different parameter types or counts. The compiler looks at the arguments in each call and picks the best match. This choice is called overload resolution and it happens at compile time.

#include <iostream>
#include <string>

double area(double side) { return side * side; }                 // square
double area(double length, double width) { return length * width; }  // rectangle
std::string area(const std::string& city) { return city + " district"; }

int main() {
    std::cout << area(4.0) << '\n';          // 16
    std::cout << area(4.0, 2.5) << '\n';     // 10
    std::cout << area("Pune") << '\n';       // Pune district
}

Default arguments

#include <iostream>

double ticket(double base, bool tatkal = false, int passengers = 1) {
    double fare = tatkal ? base + 300 : base;
    return fare * passengers;
}

int main() {
    std::cout << ticket(800) << '\n';              // 800
    std::cout << ticket(800, true) << '\n';        // 1100
    std::cout << ticket(800, true, 3) << '\n';     // 3300
}

Put the default values in the declaration (usually in the header), not again in the definition. Writing them in both places is an error.

Recursion: a function that calls itself

Some problems are naturally made of smaller copies of themselves. The factorial of 5 is 5 × factorial of 4, and so on down to 1. A recursive function solves the problem by calling itself on a smaller input. It needs two parts: a base case that answers directly and stops, and a recursive case that moves closer to the base case.

long long factorial(int n) {
    if (n <= 1) return 1;            // base case
    return n * factorial(n - 1);     // recursive case
}

int digitSum(int n) {
    if (n < 10) return n;
    return n % 10 + digitSum(n / 10);
}
// factorial(5) == 120, digitSum(4521) == 12

The call stack and stack overflow

Each call that has not finished yet keeps its variables on the call stack, a region of memory with a limited size (often 1 MB on Windows and 8 MB on Linux by default). Recursion that goes too deep, or never reaches its base case, uses up the stack and the program crashes with a stack overflow (on Linux usually "Segmentation fault").

inline and constexpr functions (a quick note)

Small functions can be marked inline, which mainly means "this definition may appear in several files" (useful in headers). A constexpr function can be evaluated at compile time when its arguments are constants, for example constexpr int square(int n) { return n * n; } lets you write int grid[square(4)];.