Function Overloading and Name Mangling

Why Overloading? A Tale of Two Compilers

In C, every function must have a unique name. If you wanted to print an integer and a double, you'd need two differently named functions:

void print_int(int value);
void print_double(double value);

This is because the C compiler generates a simple symbol, like _print_int, for the linker. Having two functions with the same name would create a "duplicate symbol" error during linking.

C++, however, allows you to give both functions the same name, as long as their parameter lists differ. This is called function overloading.

void print(int value);
void print(double value);

print(42);     // Calls the int version
print(3.14);   // Calls the double version

How is this possible? The answer lies in name mangling, which we've touched on before. The C++ compiler encodes the function's parameter types directly into the symbol name. Let's see a practical demonstration of this.

The video shows that the compiler transforms the C++ source code into symbols the linker can differentiate. For example, following the Itanium C++ ABI (used by GCC and Clang):

This mangling is the enabling mechanism for overloading. It ensures each overload has a unique identity. But it doesn't explain how the compiler chooses which one to call. That's the job of overload resolution.

The Algorithm: How the Compiler Chooses an Overload

When you write print(42);, the compiler follows a strict, multi-step algorithm at compile-time to find the best possible match among all the print functions it knows about.

Let's walk through this process. A fantastic article from Preshing on Programming, "How C++ Resolves a Function Call," provides a clear roadmap which we will follow.

As the article explains, the process begins with name lookup, which creates a set of candidate functions. This set includes all functions with the right name in the current scope, plus any found via ADL.

Once the candidate set is built (including any functions generated from templates), the real overload resolution begins. This is a three-stage filtering and ranking process:

1. Find Viable Functions: The compiler iterates through the candidate set and keeps only the functions that could be called. A function is "viable" if it has the right number of parameters (or default arguments) and if there's a way to convert each argument from the call to the type of the corresponding parameter.

2. Rank Viable Functions: The compiler then ranks the viable functions to find the "best" one. This ranking is based on the "cost" of the implicit conversions required for each argument. An exact match is best, followed by promotions, and finally other standard conversions.

3. Apply Tie-breakers: If, after ranking, two or more functions are considered equally "best", the compiler uses a set of tie-breaker rules to pick a winner. If no single winner can be found, the call is ambiguous, and you get a compile error.

The CppCon talk "Back To Basics: Overload Resolution" gives an excellent deep dive into these rules with some non-obvious examples that really test your understanding.

The key takeaway from the video is the ranking of implicit conversions:

1. Exact Match: No conversion needed. This is the best. (e.g., int to int, or an lvalue to a reference T&).
2. Promotion: Converting a "smaller" integer type to int. (e.g., short to int). These are considered very cheap.
3. Conversion: All other standard conversions (e.g., int to float, int to long long, pointer to bool).
4. User-Defined Conversion: Conversions involving class types (e.g., from a const char* to a std::string via a constructor).
5. Ellipsis Conversion: Matching the ... in a C-style variadic function. This is the worst match.

A function is considered a "better" match than another if it has at least one argument that is a better match, and no other arguments that are a worse match.

void process(long val);      // Overload 1
void process(double val);    // Overload 2

void execute() {
    process('a'); // 'a' is a character literal of type char
}

Breaking the Tie

What happens if two functions are equally good matches? For example, a non-template function and a template function that instantiates to the exact same signature.

The main tie-breaking rules are:

1. If one function is a non-template and the other is a template specialization, the non-template function is preferred.
2. If both are template specializations, the more specialized template is preferred. For example, a template taking T* is more specialized than one taking T.

If, after all these rules, there is still no single best function, the compiler issues an "ambiguous call" error. When you see this error, it's your job to guide the compiler, perhaps by using an explicit static_cast to make your intention clear.

Conclusion

Today we connected the dots between name mangling and function overloading, and then took a deep dive into the compiler's decision-making process.

Key Takeaways:

• Function Overloading allows multiple functions to share the same name, provided their parameter lists are different in type or number.
• Name Mangling is the underlying mechanism that makes this possible, by creating a unique, decorated name for each overload for the linker to use.
• Overload Resolution is the compile-time algorithm used to select the best function for a given call. It follows a strict sequence:
  1. Name Lookup: Find all candidate functions.
  2. Viability Check: Filter for functions that could possibly be called.
  3. Ranking: Find the best match(es) based on the cost of implicit argument conversions (Exact > Promotion > Conversion).
  4. Tie-Breaking: If necessary, apply rules like preferring non-templates over templates.
• An ambiguous call error means the compiler found more than one "best" match and cannot decide between them.

In our next lesson, we will explore const correctness. You'll see how the const keyword not only helps you write safer code but also participates in overload resolution, allowing you to provide different behaviors for const and non-const objects. This will build directly on the ranking and viability rules we learned today.