How Functions Are Differentiated

In the previous lesson, we learned that function overloading allows multiple functions to share the same name, provided they can be distinguished from one another. But what exactly makes functions distinguishable? This lesson explores the specific criteria the compiler uses to tell overloaded functions apart.

Criteria for Distinguishing Functions

When evaluating whether functions are distinct, the compiler examines several properties:

Properties used for differentiation:

  • Number of parameters
  • Types of parameters (excluding type aliases and const on value parameters)

Properties NOT used for differentiation:

  • Return type

Let's explore each of these in detail.

Distinguishing by Parameter Count

The simplest way to create distinct overloads is by varying the number of parameters:

int findMax(int a, int b)
{
    return (a > b) ? a : b;
}

int findMax(int a, int b, int c)
{
    int temp{ (a > b) ? a : b };
    return (temp > c) ? temp : c;
}

int findMax(int a, int b, int c, int d)
{
    int temp1{ (a > b) ? a : b };
    int temp2{ (c > d) ? c : d };
    return (temp1 > temp2) ? temp1 : temp2;
}

These three functions are clearly different because they accept different numbers of arguments. When you call findMax(10, 20), the compiler knows to use the two-parameter version. When you call findMax(10, 20, 30), it uses the three-parameter version.

Distinguishing by Parameter Types

Functions with the same number of parameters can still be differentiated if their parameter types differ:

double calculate(double length, double width)  // both double
{
    return length * width;
}

double calculate(int quantity, double price)   // int and double
{
    return quantity * price;
}

double calculate(double price, int quantity)   // double and int
{
    return price * quantity;
}

All three versions accept two parameters, but the types differ, making them distinct. Note that parameter order matters: a function taking (int, double) is different from one taking (double, int).

Type Aliases Don't Create New Overloads

Type aliases and typedefs don't create new types—they're just alternate names for existing types. Therefore, they can't be used to differentiate functions:

using Miles = int;
using Kilometers = int;

void printDistance(int distance);
void printDistance(Miles distance);      // Error: not different from int
void printDistance(Kilometers distance); // Error: not different from int

Since Miles and Kilometers are just aliases for int, all three declarations refer to the same function.

The const Qualifier on Value Parameters Doesn't Matter

When parameters are passed by value, adding const doesn't create a different function:

void displayNumber(int value);
void displayNumber(const int value); // Error: not different

From the caller's perspective, these functions are identical. The const only affects the function's implementation (preventing modification of the local copy), not how it's called.

Return Types Are Not Used for Differentiation

The compiler ignores return types when distinguishing overloaded functions. This is not allowed:

int generateNumber();
double generateNumber(); // Error: differs only by return type

Why doesn't this work? Consider this function call:

generateNumber();

The compiler has no way to determine which version you want. The return type becomes clear only when you use the returned value, but by then it's too late—the function has already been called.

If you need functions that return different types, give them different names:

int generateInteger();
double generateFloatingPoint();

What is a Function Signature?

A function's signature consists of the parts used to identify it uniquely:

  • Function name
  • Number of parameters
  • Parameter types
  • Function-level qualifiers (for member functions)

The return type is explicitly excluded from the signature.

Name Mangling: Behind the Scenes

When the compiler processes your code, it performs name mangling—altering function names to include information about their parameters. This gives the linker unique names to work with.

For example:

  • void process() might become _Z7processv
  • void process(int) might become _Z7processi
  • void process(int, double) might become _Z7processid

The exact mangling scheme varies between compilers. What matters is that each overloaded function gets a unique internal name, even though they share the same name in your source code.

Key Concept
Two functions are considered distinct if they have different parameter counts or different parameter types. Return type alone is never sufficient for differentiation.

Summary

Understanding how the compiler differentiates overloaded functions helps you design better APIs:

Valid Differentiation Criteria:

  • Parameter count: Functions with different numbers of parameters are distinct
  • Parameter types: Functions with different parameter types are distinct
  • Parameter order: (int, double) is different from (double, int)

Invalid Differentiation Criteria:

  • Return type: Cannot differentiate functions by return type alone
  • Type aliases: using and typedef don't create new types
  • const on value parameters: const int is the same as int for overload purposes

Function Signature:

  • Includes: name, parameter count, parameter types
  • Excludes: return type
  • The compiler uses name mangling to create unique internal names for each overload