Sobrecarga de funciones

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy — lección 57 de 104.

La sobrecarga de funciones te permite definir múltiples funciones con el mismo nombre pero con diferentes listas de parámetros. El compilador selecciona la versión correcta basándose en los argumentos que pases. Esta es una forma clave de polimorfismo en tiempo de compilación.

Para que la sobrecarga funcione, las funciones deben diferir en su firma: el número de parámetros, sus tipos, o ambos:

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }
    
    double add(double a, double b) {
        return a + b;
    }
    
    int add(int a, int b, int c) {
        return a + b + c;
    }
};

Calculator calc;
calc.add(5, 3);        // Llama a add(int, int)
calc.add(2.5, 3.7);    // Llama a add(double, double)
calc.add(1, 2, 3);     // Llama a add(int, int, int)

El compilador examina cada llamada y la asocia con la sobrecarga adecuada. Esto ocurre completamente en tiempo de compilación, por lo que no hay sobrecarga en tiempo de ejecución.

Importante: El tipo de retorno por sí solo no distingue las funciones sobrecargadas. Lo siguiente causaría un error de compilación:

int getValue();
double getValue();  // Error: no se puede sobrecargar solo por el tipo de retorno

La sobrecarga de funciones hace que su código sea más intuitivo. En lugar de crear nombres separados como addInts, addDoubles y addThreeInts, utiliza un único nombre significativo y deja que el compilador se encargue del resto.

Desafío

Fácil

Vamos a construir una clase formateadora de mensajes que demuestre el poder de la sobrecarga de funciones. Crearás una clase Formatter con múltiples métodos format() que manejan diferentes tipos de entrada, permitiendo que el compilador elija la versión correcta basándose en lo que le pases.

Organizarás tu código en dos archivos:

Formatter.h: Define una clase Formatter con métodos format() sobrecargados que manejen diferentes escenarios:
- Un método que toma un solo std::string e imprime: Message: <text>
- Un método que toma un std::string y un nivel de prioridad int, imprimiendo: [Priority <priority>] <text>
- Un método que toma un std::string y una marca de tiempo double, imprimiendo: [<timestamp>s] <text>
- Un método que toma tres parámetros std::string (sender, receiver, message) e imprime: From <sender> to <receiver>: <message>
Todos los métodos deben llamarse format() — el compilador seleccionará el correcto basándose en los argumentos.
main.cpp: Lee cuatro entradas (cada una en una línea separada):
1. Un texto de mensaje simple
2. Un nivel de prioridad (entero)
3. Una marca de tiempo (double)
4. Un nombre de remitente
Crea un objeto Formatter y demuestra los cuatro métodos sobrecargados:
- Llama a format() solo con el texto del mensaje
- Llama a format() con el texto del mensaje y la prioridad
- Llama a format() con el texto del mensaje y la marca de tiempo
- Llama a format() con el remitente, "Admin" como receptor, y el texto del mensaje

Por ejemplo, con las entradas System ready, 3, 12.5, y Server:

Message: System ready
[Priority 3] System ready
[12.5s] System ready
From Server to Admin: System ready

Observa cómo llamas al mismo nombre de método format() cuatro veces, pero cada llamada invoca una versión diferente basada en los tipos y la cantidad de argumentos. Esto es polimorfismo en tiempo de compilación en acción: el compilador determina qué sobrecarga usar incluso antes de que el programa se ejecute.

Hoja de referencia

La sobrecarga de funciones permite definir múltiples funciones con el mismo nombre pero con diferentes listas de parámetros. El compilador selecciona la versión correcta basándose en los argumentos pasados en tiempo de compilación.

Las funciones deben diferir en su firma: el número de parámetros, sus tipos, o ambos:

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }
    
    double add(double a, double b) {
        return a + b;
    }
    
    int add(int a, int b, int c) {
        return a + b + c;
    }
};

Calculator calc;
calc.add(5, 3);        // Llama a add(int, int)
calc.add(2.5, 3.7);    // Llama a add(double, double)
calc.add(1, 2, 3);     // Llama a add(int, int, int)

Importante: El tipo de retorno por sí solo no puede distinguir funciones sobrecargadas:

int getValue();
double getValue();  // Error: no se puede sobrecargar solo por el tipo de retorno

La sobrecarga de funciones es una forma de polimorfismo en tiempo de compilación sin sobrecarga en tiempo de ejecución.

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "Formatter.h"

using namespace std;

int main() {
    // Leer las entradas
    string message;
    getline(cin, message);
    
    int priority;
    cin >> priority;
    
    double timestamp;
    cin >> timestamp;
    cin.ignore();
    
    string sender;
    getline(cin, sender);
    
    // TODO: Crear un objeto Formatter
    
    // TODO: Llamar a format() solo con el texto del mensaje
    
    // TODO: Llamar a format() con el texto del mensaje y priority
    
    // TODO: Llamar a format() con el texto del mensaje y timestamp
    
    // TODO: Llamar a format() con sender, "Admin" como receptor, y el texto del mensaje
    
    return 0;
}