Code Comprehensibility and Function Overloading

Function overloading lets several functions share one name as long as their parameter lists differ.

Programming

Testing the Belief That the Compiler Always Finds the Right Function

When a programmer first sees several functions that share one name, a natural belief forms: the compiler will somehow work out which version was meant, and any call will be handled sensibly. This belief is partly right and partly dangerous. Function overloading is a real feature of C++, and it does let the compiler choose between functions with the same name. But the choice is not guesswork. It depends on the arguments in each call, and some calls give the compiler no basis for a single choice.

What do you think happens?

Two overloads are declared with the parameter lists (int, double) and (double, int). A program then makes the call print(0,0). Will the compiler pick one of the two overloads, or will it report a problem?

The compiler picks the (int, double) overload
The compiler picks the (double, int) overload
The compiler reports a problem and does not pick either overload

Reveal answer

Answer:

The compiler reports a problem and does not pick either overload. The call is ambiguous and the compiler reports an error.

Both zeros are integers. The (int, double) overload fits the first argument but needs a conversion for the second, while the (double, int) overload fits the second argument but needs a conversion for the first. Neither declaration is a clearly better fit for both arguments, so the compiler has no single choice.

The misconception to correct is the assumption that the compiler can resolve any call to an overloaded name. It cannot. Calls whose argument types leave no single best match cause the compiler to report an error rather than pick one. This article starts from the wrong belief, tests it with a concrete case, and then explains what the compiler actually does.

One Name, Several Separate Functions

Function overloading is defined as allowing multiple functions with the same name, as long as they have different parameter lists. The name is shared, but each definition is a separate function with its own parameter list. The name print is not one function that handles every type. It is a set of functions that the compiler treats as alternatives to one another.

Each call to print reaches a different overload, depending on the type of its argument.

cpp

void print(int value);
void print(double value);
void print(std::string text);

void print(int value);
void print(double value);
void print(std::string text);

The three declarations above all use the name print, and each takes a different type of argument. Because the parameter lists differ, the compiler can tell the three functions apart at each call site. The same name can therefore invoke different functions in different places in the same program.

How the Compiler Chooses a Call Target

The compiler resolves each call based on the number and types of its arguments. The choice is made from the argument types at that specific call site, not from the order in which the functions were declared. The flowchart below shows the decision made for every call to an overloaded name.

The compiler collects the functions with the called name, then checks whether one of them is most appropriate for the argument types. If none is better than the others, the call is ambiguous.

The source describes the outcome of this comparison but does not list the full ranking rules the compiler uses. What you can rely on are the observable results: a call that singles out one overload succeeds, and a call that leaves two or more equally suitable candidates is rejected.

Tracing Three Calls Through One Function

Next, trace what happens to each call in a function that makes three different calls to the overloaded name. The comments in the code name the overload each call reaches. Before reading the comments, try to match each argument to a parameter list yourself.

cpp

void user() {
    print(42);                  // integer argument: selects print(int)
    print(9.65);               // floating-point argument: selects print(double)
    print("D is for Digital");  // string argument: selects print(std::string)
}

void user() {
    print(42);                  // integer argument: selects print(int)
    print(9.65);               // floating-point argument: selects print(double)
    print("D is for Digital");  // string argument: selects print(std::string)
}

Walk through it

1
Line 1: the argument 42 is an integer, so the compiler looks for an overload whose parameter list fits an integer and selects print(int).
2
Line 2: the argument 9.65 is a floating-point value, so the compiler selects print(double).
3
Line 3: the argument is a string, so the compiler selects print(std::string).

Notes on the code

Each call matches a different parameter list, so each call reaches a different function.
The function bodies are not involved in the choice; only the call's arguments are.

Worked example

Resolving the call print(42)

Given the three overloads print(int), print(double), and print(std::string), which function does the call print(42) invoke?

1
Collect the candidates
The compiler gathers every function named print: print(int), print(double), and print(std::string).
2
Compare the argument type
The argument 42 is an integer, so it matches the parameter list of print(int) directly.
3
Check for a single best choice
The integer argument gives the compiler one overload that fits best, so the call is not ambiguous.
4
Invoke the function
The compiler invokes print(int).

Result

print(42) invokes print(int).

EASY

Without looking back at the code, state which overload each of the three calls in user() reaches, and explain in one sentence what in each call determined your answer.

Hints

Look only at the type of each argument, not at the name print.
The declaration order of the overloads does not decide the choice.

Your attempt (not saved)

Why print(0,0) Has No Single Winner

Now consider the case from the start of the article. The source declares two overloads whose parameter types are swapped in position: print(int, double) and print(double, int). Both take two arguments, but one expects the integer first and the other expects it second.

cpp

void print(int a, double b);
void print(double a, int b);

void user() {
    print(0, 0);   // ambiguous call
}

void print(int a, double b);
void print(double a, int b);

void user() {
    print(0, 0);   // ambiguous call
}

Walk through it

1
Both arguments are integers, so the first argument fits the int position of the first overload but needs conversion to double in the second position.
2
The second overload fits the second argument but needs conversion to double in the first position.
3
Neither overload is a clearly better fit for both arguments, so the call is ambiguous and the compiler reports an error.

Notes on the code

Both declarations are valid on their own; the problem appears only at the call.

A valid call leaves one overload to invoke. An ambiguous call leaves two equally suitable candidates and no rule that favors either, so the compiler stops with an error.

This is why the source describes the situation as ambiguous rather than as a call that works and prints something. The ambiguity error appears at the call site, which is where you should check the call against every overload of its name. The declarations themselves were never the problem; the problem appears only when a call uses them in a way that does not single out one function.

Mistakes When Writing and Reading Overloads

Common mistake
Assuming the compiler will always find the right overload
What it looks like
Writing print(int, double) and print(double, int) and then calling print(0, 0), expecting one of them to be chosen.
Why it fails
The compiler chooses only when one candidate is most appropriate for the argument types. When two candidates are equally suitable, there is no single choice.
Do this instead
Check each call against every overload of its name and confirm that exactly one fits best before relying on the compiler to choose.
Common mistake
Writing overloads whose parameter lists are too close together
What it looks like
Two overloads whose parameter types are the same pair of types in swapped positions, so that a call with two identical arguments could fit either one.
Why it fails
The source indicates that ambiguity arises when overloaded functions have parameter lists that are not sufficiently distinct for a realistic call.
Do this instead
Compare the parameter lists against each other and ask whether a realistic call could fit more than one of them equally well. If it could, change the declarations so the calls are distinguishable.
Common mistake
Thinking the order of declarations decides which overload runs
Why it fails
The choice is made from the argument types at each call site, not from the order in which the functions were declared.
Common mistake
Treating a shared name as one function that handles every type
Why it fails
Each overload is a separate function with its own parameter list. The name is shared, but the compiler treats the overloads as alternatives.

Checking Your Reading of Ambiguous Calls

Use the two swapped overloads from the previous section, print(int, double) and print(double, int), to test your understanding. Explain in your own words why the call print(0, 0) has no single winner, and state which of the two parts of the reasoning, the first argument or the second argument, pulls each overload in a different direction.

MEDIUM

You want print(0, 0) to call exactly one function. Describe one change you could make to the overload declarations, and explain how that change removes the tie between the two candidates. You may also describe a change to the call instead, and explain which of the two options fits the source's advice.