What is Function Overloading in C++

Function overloading is a feature of C++ that allows you to define multiple versions of functions with the same name but with different parameter lists.

The C++ compiler decides which version of the function to invoke based on the types and number of arguments passed in the function call.

This provides flexibility and avoids the need to use different function names for similar operations.

Syntax of Overloading

To use function overloading, functions must differ by at least one aspect of their parameters: the type or the number of arguments.

#include <iostream>

// Function to add two integers
int Add(int a, int b) {
    return a + b;
}

// Function to add three integers
int Add(int a, int b, int c) {
    return a + b + c;
}

// Function to add two floating-point numbers
double Add(double a, double b) {
    return a + b;
}

int main() {
    std::cout << "Sum of 2 and 3: " << Add(2, 3) << std::endl;           // Calls Add(int, int)
    std::cout << "Sum of 1, 2, and 3: " << Add(1, 2, 3) << std::endl;    // Calls Add(int, int, int)
    std::cout << "Sum of 2.5 and 3.5: " << Add(2.5, 3.5) << std::endl;   // Calls Add(double, double)

    return 0;
}

In this example, the function Add is overloaded in three ways:

• To add two integers.
• To add three integers.
• To add two floating-point numbers.

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

// This is not valid, as it only differs by the return type
double MyMethod(int a, int b) {
    return static_cast<double>(a + b);
}

Practical Examples

Calculate the Area of a Rectangle

You can overload a function to calculate the area of a rectangle based on different sets of parameters:

#include <iostream>

// Function to calculate the area of a rectangle using length and width
double CalculateArea(double length, double width) {
    return length * width;
}

// Function to calculate the area of a square using one side
double CalculateArea(double side) {
    return side * side;
}

int main() {
    double areaRectangle = CalculateArea(5.0, 3.0); // Calls CalculateArea(double, double)
    double areaSquare = CalculateArea(4.0);        // Calls CalculateArea(double)

    std::cout << "Area of the rectangle: " << areaRectangle << std::endl;
    std::cout << "Area of the square: " << areaSquare << std::endl;

    return 0;
}

Here, CalculateArea is overloaded to handle both rectangles and squares, using different numbers of parameters.

Overloading to Add Numbers

Another common application of overloading is to add numbers of different types:

#include <iostream>

// Function to add two integers
int Add(int a, int b) {
    return a + b;
}

// Function to add two floating-point numbers
double Add(double a, double b) {
    return a + b;
}

int main() {
    int sumIntegers = Add(3, 5);       // Calls Add(int, int)
    double sumDecimals = Add(3.5, 5.7); // Calls Add(double, double)

    std::cout << "Sum of integers: " << sumIntegers << std::endl;
    std::cout << "Sum of decimals: " << sumDecimals << std::endl;

    return 0;
}

This code shows how to overload the Add function to work with integers and decimal numbers, making it easy to use the same function for different data types.

Print Employee Information

You can overload a function to print different levels of information about an employee:

#include <iostream>

// Function to print basic information of an employee
void PrintEmployee(const std::string& name, int age) {
    std::cout << "Employee: " << name << ", Age: " << age << std::endl;
}

// Function to print complete information of an employee
void PrintEmployee(const std::string& name, int age, const std::string& department) {
    std::cout << "Employee: " << name << ", Age: " << age << ", Department: " << department << std::endl;
}

int main() {
    PrintEmployee("John", 30);             // Calls PrintEmployee(const std::string&, int)
    PrintEmployee("Maria", 25, "Sales");  // Calls PrintEmployee(const std::string&, int, const std::string&)

    return 0;
}

In this example, PrintEmployee is overloaded to accept either two or three parameters, providing flexibility to print different levels of detail.