8.10 — Function overload differentiation

In the prior lesson (8.9 -- Introduction to function overloading), we introduced the concept of function overloading, which allows us to create multiple functions with the same name, so long as each identically named function has different parameter types (or the functions can be otherwise differentiated).

In this lesson, we’ll take a closer look at how overloaded functions are differentiated. Overloaded functions that are not properly differentiated will cause the compiler to issue a compile error.

How overloaded functions are differentiated

Note that a function’s return type is not used to differentiate overloaded functions. We’ll discuss this more in a bit.

Overloading based on number of parameters

An overloaded function is differentiated so long as each overloaded function has a different number of parameters. For example:

int add(int x, int y)
{
    return x + y;
}

int add(int x, int y, int z)
{
    return x + y + z;
}

The compiler can easily tell that a function call with two integer parameters should go to add(int, int) and a function call with three integer parameters should go to add(int, int, int).

Overloading based on type of parameters

A function can also be differentiated so long as each overloaded function’s list of parameter types is distinct. For example, all of the following overloads are differentiated:

int add(int x, int y); // integer version
double add(double x, double y); // floating point version
double add(int x, double y); // mixed version
double add(double x, int y); // mixed version

Because type aliases (or typedefs) are not distinct types, overloaded functions using type aliases are not distinct from overloads using the aliased type. For example, all of the following overloads are not differentiated (and will result in a compile error):

typedef int height_t; // typedef
using age_t = int; // type alias

void print(int value);
void print(age_t value); // not differentiated from print(int)
void print(height_t value); // not differentiated from print(int)

For parameters passed by value, the const qualifier is also not considered. Therefore, the following functions are not considered to be differentiated:

void print(int);
void print(const int); // not differentiated from print(int)

void foo(int x, int y);
void foo(int x, ...); // differentiated from foo(int, int)

The return type of a function is not considered for differentiation

A function’s return type is not considered when differentiating overloaded functions.

Consider the case where you want to write a function that returns a random number, but you need a version that will return an int, and another version that will return a double. You might be tempted to do this:

int getRandomValue();
double getRandomValue();

On Visual Studio 2019, this results in the following compiler error:

error C2556: 'double getRandomValue(void)': overloaded function differs only by return type from 'int getRandomValue(void)'

This makes sense. If you were the compiler, and you saw this statement:

getRandomValue();

Which of the two overloaded functions would you call? It’s not clear.

The best way to address this is to give the functions different names:

int getRandomInt();
double getRandomDouble();

Type signature

A function’s type signature (generally called a signature) is defined as the parts of the function header that are used for differentiation of the function. In C++, this includes the function name, number of parameter, parameter type, and function-level qualifiers. It notably does not include the return type.

Name mangling