Functions: Declaration, Definition, and Overloading

Anatomy of a function

A function definition has four parts: the return type, the name, the parameter list (possibly empty), and the body. The return type tells the caller what kind of value to expect back. void means the function returns nothing.

// return_type  name  ( parameter_list )
// {
//     body
// }

double cubeVolume(double sideLength)
{
    double volume = sideLength * sideLength * sideLength;
    return volume;
}

// Calling the function:
double v = cubeVolume(3.0);  // v = 27.0

// void function — returns nothing
void printLine(const std::string& text)
{
    std::cout << text << "\n";
    // no return statement needed (or use bare 'return;')
}

The return statement terminates the function and sends a value back to the caller. For non-void functions, every code path must reach a return — a function that can fall off the end without returning causes undefined behavior.

Declarations vs definitions — the prototype

The C++ compiler processes a file from top to bottom. If you call a function before its definition appears in the file, the compiler complains that it doesn't know what the function is. There are two solutions: define the function before calling it, or provide a function prototype (also called a declaration) that tells the compiler the function's signature without providing the body.

// Without prototype: must define BEFORE use
double cube(double x) { return x * x * x; }

int main()
{
    std::cout << cube(3.0);  // fine: cube is already defined above
}

// With prototype: can define AFTER use
double cube(double x);   // ← prototype/declaration (note the semicolon)

int main()
{
    std::cout << cube(3.0);  // fine: compiler knows the signature
}

double cube(double x)     // actual definition can be anywhere after
{
    return x * x * x;
}

In practice, prototypes live in header files (.h or .hpp) which are #included at the top of files that call the function. Definitions live in .cpp files. This separation lets multiple .cpp files use the same function without duplicating the body.

Parameters and arguments

Parameters are the variables listed in the function signature. Argumentsare the actual values passed when calling the function. By default, arguments are passed by value: the function receives a copy, and modifying the parameter does not affect the caller's variable. (Passing by reference or pointer — the main alternatives — is covered in the next lesson.)

// Parameters: left, right
// Arguments: 5, 3
int add(int left, int right)
{
    return left + right;
}

int result = add(5, 3);   // result = 8

// Multiple parameters of different types:
std::string repeat(const std::string& word, int times)
{
    std::string result;
    for (int i = 0; i < times; ++i)
        result += word;
    return result;
}

std::cout << repeat("ha", 3);  // prints "hahaha"

Multiple returns and return values

A function can have multiple return statements. The first one reached terminates the function. This is commonly used to implement early-return patterns for guard conditions. C++ functions return exactly one value — to return multiple values, return a struct, use output parameters (references), or return a std::pair / std::tuple.

// Multiple returns:
std::string classify(int n)
{
    if (n < 0)  return "negative";
    if (n == 0) return "zero";
    if (n % 2 == 0) return "positive even";
    return "positive odd";
}

// Returning multiple values via struct (clean modern style):
struct MinMax { int min; int max; };

MinMax findMinMax(const std::vector<int>& v)
{
    int lo = v[0], hi = v[0];
    for (int x : v) {
        if (x < lo) lo = x;
        if (x > hi) hi = x;
    }
    return {lo, hi};
}

auto [lo, hi] = findMinMax({3, 1, 4, 1, 5, 9});
std::cout << lo << " " << hi;  // 1 9

Function overloading

C++ allows multiple functions to share the same name as long as their parameter lists differ (different types, different number of parameters, or both). The compiler selects the correct version at each call site based on the types of the arguments. Overloading the return type alone is not sufficient — the compiler cannot distinguish two functions that take the same parameters but return different types.

// Three overloads of 'area':
double area(double radius)
{
    return 3.14159 * radius * radius;   // circle
}

double area(double width, double height)
{
    return width * height;              // rectangle
}

int area(int side)
{
    return side * side;                 // square (integer version)
}

// Compiler picks the right one based on argument types:
std::cout << area(5.0);          // calls circle version  → 78.54
std::cout << area(4.0, 3.0);    // calls rectangle version → 12.0
std::cout << area(4);           // calls int square version → 16

Overloading is especially useful when you want a function to work with different types in a natural way — the standard library overloads std::abs, operators like + and <<, and many other names extensively. Avoid overloading when the functions do fundamentally different things — names should communicate meaning.

Key rules to remember