Function Overloading in C++

Function overloading lets you give the same name to several functions as long as their parameter lists differ — in number, types, or order. The compiler picks the right one based on the arguments you pass. It is a form of compile-time polymorphism that keeps related operations under one clear name instead of inventing printInt, printDouble, printString.

Here is the core idea.

Overloading by parameter type and count

#include <iostream>
#include <string>

void show(int n) {
    std::cout << "int: " << n << "\n";
}

void show(double d) {
    std::cout << "double: " << d << "\n";
}

void show(const std::string& s) {
    std::cout << "string: " << s << "\n";
}

int main() {
    show(42);            // calls show(int)
    show(3.14);          // calls show(double)
    show(std::string{"hello"});  // calls show(const std::string&)
}

Output:

int: 42
double: 3.14
string: hello

All three functions share the name show. The compiler reads the argument type and selects the matching version — this selection is called overload resolution.

What counts as a different signature

Two overloads must differ in their parameters. They may differ by:

• Number of parameters: add(int, int) vs add(int, int, int)
• Types of parameters: area(double) vs area(double, double)
• Order of types: combine(int, std::string) vs combine(std::string, int)

The return type alone is not enough. int f(); and double f(); are not valid overloads — the compiler cannot tell them apart from the call.

Overloading member functions

Overloading works on class methods too, which is common for constructors and operations.

#include <iostream>

class Calculator {
public:
    int multiply(int a, int b) const { return a * b; }
    double multiply(double a, double b) const { return a * b; }
};

int main() {
    Calculator c;
    std::cout << c.multiply(3, 4) << "\n";      // int version -> 12
    std::cout << c.multiply(1.5, 2.0) << "\n";  // double version -> 3
}

Overloading vs default arguments

Sometimes a default argument is simpler than a second overload:

// one function with an optional second parameter
void greet(const std::string& name, const std::string& title = "friend") {
    std::cout << "Hello, " << title << " " << name << "\n";
}

greet("Asha");            // uses default title
greet("Asha", "Dr.");     // overrides it

Reach for default arguments when the variants share one body; reach for overloads when the variants need genuinely different code.

How the compiler chooses

When you call an overloaded function, the compiler runs overload resolution in three rough steps. First it gathers every overload with the right name (the candidate set). Then it discards any whose parameters cannot accept the arguments (the viable set) — for example, show("text") cannot call show(int). Finally, among the survivors it picks the best match, preferring an exact type match over one that needs a conversion. An exact match beats a promotion (like int to long), which in turn beats a standard conversion (like int to double). If two overloads tie for best, the call is ambiguous and fails to compile — the compiler refuses to guess.

Understanding this order explains most overloading surprises: a call you expected to reach one overload may instead match another because it needs fewer or cheaper conversions.

A practical guideline

Keep overload sets small and obviously distinct. If two overloads differ only by a conversion the caller might not notice, you invite ambiguity and confusion. When in doubt, give the functions clearer, separate names instead — readability beats cleverness.

Common mistakes

• Trying to overload on return type only. int f(); and double f(); is a compile error. The parameters must differ.
• Ambiguous calls. If you overload f(int) and f(double) and call f(5L) (a long), the compiler may not find a single best match and will report an ambiguity.
• Mixing overloads and default arguments carelessly. greet(name) may match both an overload and a defaulted version, creating ambiguity. Pick one approach per name.
• Assuming const differences are enough. void g(int) and void g(const int) are the same signature for a by-value parameter and cannot coexist.

FAQ

Can the return type alone distinguish two overloads? No. Overloads must differ in their parameter list. The compiler chooses based on arguments at the call site, where the return type is not visible.

Is overloading the same as overriding? No. Overloading is choosing among same-named functions by parameters at compile time. Overriding is a derived class replacing a base class's virtual function, resolved at run time.

Keep learning

• See the related compile-time mechanism in Operator Overloading in C++.
• Compare it with run-time behaviour in Polymorphism in C++.
• Browse all topics on the C++ OOP hub.

Practise with real exercises and mentors in Jalgaon — join the waitlist for our C++ Programming course.