Function overloading is a feature in C++ that allows you to define multiple functions with the same name, but with different parameters. When you call an overloaded function, the compiler decides which function to call based on the arguments you pass to it.

Here's an example of function overloading:

int add(int x, int y) {
    return x + y;
}

double add(double x, double y) {
    return x + y;
}

int main() {
    int result1 = add(3, 4);
    double result2 = add(3.5, 4.2);
    return 0;
}

In this example, there are two functions named add. One takes two int parameters and returns an int, and the other takes two double parameters and returns a double. When you call add with int arguments, the first function is called, and when you call it with double arguments, the second function is called.

Function overloading is useful when you want to perform similar operations on different types of data. Instead of creating separate functions with different names, you can define a single function with the same name and let the compiler handle the details of selecting the appropriate version based on the types of the arguments.

Note that function overloading is based on the parameters of the function, not on its return type. You cannot overload functions that have the same name and parameter types but different return types.