C++ Function Overloading: Same Name, Different Parameters

Imagine you want a function called print that can handle an int, a double, and a std::string. Without overloading you’d need three different names — printInt, printDouble, printString. With function overloading, all three can just be called print, and C++ figures out which one to use.

What Is Function Overloading?

Function overloading means defining multiple functions with the same name but different parameter lists. The compiler resolves which function to call at compile time based on the types and number of arguments you pass.

#include <iostream>
#include <string>

void print(int value) {
    std::cout << "Integer: " << value << "\n";
}

void print(double value) {
    std::cout << "Double: " << value << "\n";
}

void print(std::string value) {
    std::cout << "String: " << value << "\n";
}

int main() {
    print(42);           // calls print(int)
    print(3.14);         // calls print(double)
    print("hello");      // calls print(std::string)
    return 0;
}

Output:

Integer: 42
Double: 3.14
String: hello

The compiler matches each call to the right version automatically. This is called overload resolution.

Overloading by Number of Parameters

You can also overload by using a different number of parameters:

#include <iostream>

int add(int a, int b) {
    return a + b;
}

int add(int a, int b, int c) {
    return a + b + c;
}

int main() {
    std::cout << add(2, 3) << "\n";      // 5
    std::cout << add(2, 3, 4) << "\n";   // 9
    return 0;
}

Both functions are named add, but one takes two integers and the other takes three. The compiler picks based on how many arguments you provide.

Why Can’t You Overload by Return Type?

A common mistake is trying to overload on return type:

// This does NOT work — compiler error
int getValue() { return 1; }
double getValue() { return 1.0; }  // error: redefinition of 'getValue'

The reason is that when you write getValue(), the compiler has no way of knowing which one you want just from that line. You might assign the result to a variable, but that information isn’t always available to the resolver. So C++ simply doesn’t allow it.

Practical Example: Area Calculator

Here’s a realistic example where overloading makes an API much cleaner:

#include <iostream>
#include <cmath>

// Area of a square
double area(double side) {
    return side * side;
}

// Area of a rectangle
double area(double width, double height) {
    return width * height;
}

// Area of a circle
double area(double radius, bool isCircle) {
    return 3.14159 * radius * radius;
}

int main() {
    std::cout << "Square area:    " << area(5.0) << "\n";
    std::cout << "Rectangle area: " << area(4.0, 6.0) << "\n";
    std::cout << "Circle area:    " << area(3.0, true) << "\n";
    return 0;
}

All three shapes use the same function name. Without overloading you’d write squareArea, rectangleArea, and circleArea — more to remember, less readable.

Function Overloading vs Default Arguments

Sometimes you can achieve a similar result with default function arguments. The key difference: overloading lets you run completely different logic per version, while defaults just fill in a missing value.

Use overloading when the logic is different. Use defaults when the logic is the same but one parameter is optional.

Common Beginner Mistakes

Ambiguous calls: If the compiler can’t decide between two overloads, it gives an error.

void show(int x) {}
void show(double x) {}

show(3.0f);  // float — ambiguous! Not clearly int or double

Fix it by being explicit: show((double)3.0f) or show(3.0).

Overloading across scopes: If one overload is in a different namespace or class, the rules get more complex. For beginners, keep all overloads in the same scope.

Related Articles

• C++ Functions Tutorial: How to Write and Use Functions
• C++ Default Arguments: Optional Parameters Explained
• C++ Operator Overloading: A Beginner’s Guide
• C++ Templates Explained: Write Code That Works with Any Type

Take Your C++ Further

If you’re looking to go deeper with C++, the C++ Better Explained Ebook is perfect for you — whether you’re a complete beginner or looking to solidify your understanding. Just $19.

👉 Get the C++ Better Explained Ebook — $19