Surcharge de fonctions

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy — leçon 57 sur 104.

La surcharge de fonction vous permet de définir plusieurs fonctions avec le même nom mais des listes de paramètres différentes. Le compilateur sélectionne la version correcte en fonction des arguments que vous passez. C'est une forme clé de polymorphisme à la compilation.

Pour que la surcharge fonctionne, les fonctions doivent différer par leur signature - le nombre de paramètres, leurs types, ou les deux :

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);        // Appelle add(int, int)
calc.add(2.5, 3.7);    // Appelle add(double, double)
calc.add(1, 2, 3);     // Appelle add(int, int, int)

Le compilateur examine chaque appel et le fait correspondre à la surcharge appropriée. Cela se produit entièrement au moment de la compilation, il n'y a donc pas de surcoût à l'exécution.

Important : Le type de retour seul ne permet pas de distinguer les fonctions surchargées. Ce qui suit provoquerait une erreur de compilation :

int getValue();
double getValue();  // Erreur : impossible de surcharger uniquement par le type de retour

La surcharge de fonctions rend votre code plus intuitif. Au lieu de créer des noms distincts comme addInts, addDoubles et addThreeInts, vous utilisez un seul nom significatif et laissez le compilateur s'occuper du reste.

Défi

Facile

Construisons une classe de formatage de messages qui démontre la puissance de la surcharge de fonctions. Vous allez créer une classe Formatter avec plusieurs méthodes format() qui gèrent différents types d'entrées, laissant le compilateur choisir la bonne version en fonction de ce que vous lui passez.

Vous organiserez votre code sur deux fichiers :

Formatter.h : Définissez une classe Formatter avec des méthodes format() surchargées qui gèrent différents scénarios :
- Une méthode qui prend une seule std::string et affiche : Message: <text>
- Une méthode qui prend une std::string et un niveau de priorité int, affichant : [Priority <priority>] <text>
- Une méthode qui prend une std::string et un horodatage double, affichant : [<timestamp>s] <text>
- Une méthode qui prend trois paramètres std::string (expéditeur, destinataire, message) et affiche : From <sender> to <receiver>: <message>
Toutes les méthodes doivent être nommées format() — le compilateur sélectionnera la bonne en fonction des arguments.
main.cpp : Lisez quatre entrées (chacune sur une ligne séparée) :
1. Un texte de message simple
2. Un niveau de priorité (entier)
3. Un horodatage (double)
4. Un nom d'expéditeur
Créez un objet Formatter et démontrez les quatre méthodes surchargées :
- Appelez format() avec seulement le texte du message
- Appelez format() avec le texte du message et la priorité
- Appelez format() avec le texte du message et l'horodatage
- Appelez format() avec l'expéditeur, "Admin" comme destinataire, et le texte du message

Par exemple, avec les entrées System ready, 3, 12.5, et Server :

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

Remarquez comment vous appelez le même nom de méthode format() quatre fois, mais chaque appel invoque une version différente basée sur les types et le nombre d'arguments. C'est le polymorphisme à la compilation en action — le compilateur détermine quelle surcharge utiliser avant même que le programme ne s'exécute.

Aide-mémoire

La surcharge de fonctions vous permet de définir plusieurs fonctions portant le même nom mais ayant des listes de paramètres différentes. Le compilateur sélectionne la version correcte en fonction des arguments transmis au moment de la compilation.

Les fonctions doivent différer par leur signature - le nombre de paramètres, leurs types, ou les deux :

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);        // Appelle add(int, int)
calc.add(2.5, 3.7);    // Appelle add(double, double)
calc.add(1, 2, 3);     // Appelle add(int, int, int)

Important : Le type de retour seul ne peut pas distinguer des fonctions surchargées :

int getValue();
double getValue();  // Erreur : impossible de surcharger uniquement par le type de retour

La surcharge de fonctions est une forme de polymorphisme à la compilation sans surcoût à l'exécution.

Essayez vous-même

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

using namespace std;

int main() {
    // Lire les entrées
    string message;
    getline(cin, message);
    
    int priority;
    cin >> priority;
    
    double timestamp;
    cin >> timestamp;
    cin.ignore();
    
    string sender;
    getline(cin, sender);
    
    // TODO: Créer un objet Formatter
    
    // TODO: Appeler format() avec seulement le texte du message
    
    // TODO: Appeler format() avec le texte du message et la priorité
    
    // TODO: Appeler format() avec le texte du message et l'horodatage timestamp
    
    // TODO: Appeler format() avec l'expéditeur sender, "Admin" comme destinataire receiver, et le texte du message
    
    return 0;
}