Surcharge de fonctions

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

Surcharge de fonctions vous permet de définir plusieurs fonctions portant le même nom, mais avec des listes de paramètres différentes. Le compilateur sélectionne la version appropriée en fonction des arguments que vous transmettez. Il s’agit d’une forme essentielle 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 l’associe à la surcharge appropriée. Cela se produit entièrement au moment de la compilation, il n’y a donc aucune surcharge à l’exécution.

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

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ée, permettant au compilateur de choisir la version appropriée en fonction de ce que vous lui transmettez.

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, et affiche : [Priority <priority>] <text>
- Une méthode qui prend une std::string et un horodatage double, et affiche : [<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 distincte) :
1. Un texte de message simple
2. Un niveau de priorité (entier)
3. Un horodatage (nombre réel)
4. Un nom d'expéditeur
Créez un objet Formatter et démontrez les quatre méthodes surchargées :
- Appelez format() avec uniquement 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 que vous appelez quatre fois le même nom de méthode format(), mais que chaque appel invoque une version différente en fonction du type et du nombre d'arguments. C'est le polymorphisme à la compilation en action : le compilateur détermine quelle surcharge utiliser avant même l'exécution du programme.

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 priority
    
    // TODO: Appeler format() avec le texte du message et timestamp
    
    // TODO: Appeler format() avec sender, "Admin" comme destinataire, et le texte du message
    
    return 0;
}