Language: EN
LuisLlamas Logo
Search
⏲️ ~ 4 minutes Intermediate
cpp-sobrecarga-funciones

What is Function Overloading in C++

Function overloading is a feature of C++ that allows the definition of 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.

If you want to learn more about function overloading
check the Introduction to Programming Course read more ⯈

Syntax of Overloading

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

#include <iostream>

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

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

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

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

    return 0;
}

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

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

It is not possible to use overloading based solely on the return type. For example, the following case would not be valid:

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

// This is not valid, as it only differs by the return type
double MiMetodo(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 CalcularArea(double longitud, double ancho) {
    return longitud * ancho;
}

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

int main() {
    double areaRectangulo = CalcularArea(5.0, 3.0); // Calls CalcularArea(double, double)
    double areaCuadrado = CalcularArea(4.0);        // Calls CalcularArea(double)

    std::cout << "Area of the rectangle: " << areaRectangulo << std::endl;
    std::cout << "Area of the square: " << areaCuadrado << std::endl;

    return 0;
}

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

Overloading to sum numbers

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

#include <iostream>

// Function to sum two integer numbers
int Sumar(int a, int b) {
    return a + b;
}

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

int main() {
    int sumaEnteros = Sumar(3, 5);       // Calls Sumar(int, int)
    double sumaDecimales = Sumar(3.5, 5.7); // Calls Sumar(double, double)

    std::cout << "Sum of integers: " << sumaEnteros << std::endl;
    std::cout << "Sum of decimals: " << sumaDecimales << std::endl;

    return 0;
}

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

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 ImprimirEmpleado(const std::string& nombre, int edad) {
    std::cout << "Employee: " << nombre << ", Age: " << edad << std::endl;
}

// Function to print complete information of an employee
void ImprimirEmpleado(const std::string& nombre, int edad, const std::string& departamento) {
    std::cout << "Employee: " << nombre << ", Age: " << edad << ", Department: " << departamento << std::endl;
}

int main() {
    ImprimirEmpleado("Luis", 30);             // Calls ImprimirEmpleado(const std::string&, int)
    ImprimirEmpleado("María", 25, "Sales");  // Calls ImprimirEmpleado(const std::string&, int, const std::string&)

    return 0;
}

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

These examples are intended to show how to use overloading. It does not mean that it is the best way to solve the problem they address. Usually, there are better alternatives.

On this page