Sobrecarga de Funções

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy — lição 57 de 104.

Sobrecarga de função permite que você defina múltiplas funções com o mesmo nome, mas com diferentes listas de parâmetros. O compilador seleciona a versão correta com base nos argumentos que você passa. Esta é uma forma fundamental de polimorfismo em tempo de compilação.

Para que a sobrecarga funcione, as funções devem diferir em sua assinatura - o número de parâmetros, seus tipos, ou 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);        // Chama add(int, int)
calc.add(2.5, 3.7);    // Chama add(double, double)
calc.add(1, 2, 3);     // Chama add(int, int, int)

O compilador examina cada chamada e a associa à sobrecarga apropriada. Isso acontece inteiramente em tempo de compilação, portanto não há sobrecarga em tempo de execução.

Importante: O tipo de retorno por si só não distingue funções sobrecarregadas. O seguinte causaria um erro de compilação:

int getValue();
double getValue();  // Erro: não é possível sobrecarregar apenas pelo tipo de retorno

A sobrecarga de funções torna seu código mais intuitivo. Em vez de criar nomes separados como addInts, addDoubles e addThreeInts, você usa um único nome significativo e deixa o compilador lidar com o resto.

Desafio

Fácil

Vamos construir uma classe formatadora de mensagens que demonstra o poder da sobrecarga de funções. Você criará uma classe Formatter com múltiplos métodos format() que lidam com diferentes tipos de entrada, permitindo que o compilador escolha a versão correta com base no que você passar.

Você organizará seu código em dois arquivos:

Formatter.h: Defina uma classe Formatter com métodos format() sobrecarregados que lidam com diferentes cenários:
- Um método que recebe uma única std::string e imprime: Message: <text>
- Um método que recebe uma std::string e um nível de prioridade int, imprimindo: [Priority <priority>] <text>
- Um método que recebe uma std::string e um timestamp double, imprimindo: [<timestamp>s] <text>
- Um método que recebe três parâmetros std::string (remetente, destinatário, mensagem) e imprime: From <sender> to <receiver>: <message>
Todos os métodos devem ser nomeados format() — o compilador selecionará o correto com base nos argumentos.
main.cpp: Leia quatro entradas (cada uma em uma linha separada):
1. Um texto de mensagem simples
2. Um nível de prioridade (inteiro)
3. Um timestamp (double)
4. Um nome de remetente
Crie um objeto Formatter e demonstre todos os quatro métodos sobrecarregados:
- Chame format() apenas com o texto da mensagem
- Chame format() com o texto da mensagem e a prioridade
- Chame format() com o texto da mensagem e o timestamp
- Chame format() com o remetente, "Admin" como o destinatário, e o texto da mensagem

Por exemplo, com as entradas System ready, 3, 12.5, e Server:

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

Observe como você chama o mesmo nome de método format() quatro vezes, mas cada chamada invoca uma versão diferente com base nos tipos e na contagem de argumentos. Isso é o polimorfismo de tempo de compilação em ação — o compilador determina qual sobrecarga usar antes mesmo do programa ser executado.

Folha de consulta

A sobrecarga de funções permite que você defina múltiplas funções com o mesmo nome, mas com listas de parâmetros diferentes. O compilador seleciona a versão correta com base nos argumentos passados em tempo de compilação.

As funções devem diferir em sua assinatura - o número de parâmetros, seus tipos, ou 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);        // Chama add(int, int)
calc.add(2.5, 3.7);    // Chama add(double, double)
calc.add(1, 2, 3);     // Chama add(int, int, int)

Importante: O tipo de retorno sozinho não pode distinguir funções sobrecarregadas:

int getValue();
double getValue();  // Erro: não é possível sobrecarregar apenas pelo tipo de retorno

A sobrecarga de funções é uma forma de polimorfismo em tempo de compilação sem sobrecarga (overhead) em tempo de execução.

Experimente você mesmo

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

using namespace std;

int main() {
    // Ler entradas
    string message;
    getline(cin, message);
    
    int priority;
    cin >> priority;
    
    double timestamp;
    cin >> timestamp;
    cin.ignore();
    
    string sender;
    getline(cin, sender);
    
    // TODO: Criar um objeto Formatter
    
    // TODO: Chamar format() apenas com o texto da mensagem
    
    // TODO: Chamar format() com o texto da mensagem e a prioridade
    
    // TODO: Chamar format() com o texto da mensagem e o timestamp
    
    // TODO: Chamar format() com o remetente, "Admin" como destinatário e o texto da mensagem
    
    return 0;
}