Polymorphisme à la compilation vs à l’exécution

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

Le polymorphisme signifie « plusieurs formes » et constitue un concept fondamental de la POO qui permet de traiter les objets de manière uniforme tout en ayant des comportements différents. C++ prend en charge deux types distincts de polymorphisme, chacun étant résolu à une étape différente de l’exécution du programme.

Le polymorphisme à la compilation (également appelé polymorphisme statique) est résolu par le compilateur avant l’exécution du programme. Le compilateur détermine exactement quelle fonction appeler en fonction de la signature de la fonction. Cela inclut la surcharge de fonctions et les modèles :

void print(int x) { std::cout << "Integer: " << x << std::endl; }
void print(double x) { std::cout << "Double: " << x << std::endl; }

print(5);      // Le compilateur choisit print(int)
print(3.14);   // Le compilateur choisit print(double)

Le polymorphisme à l’exécution (également appelé polymorphisme dynamique) est résolu pendant l’exécution du programme. La décision concernant la fonction à appeler dépend du type réel de l’objet, et non du type du pointeur ou de la référence. Cela est réalisé au moyen de fonctions virtuelles :

class Shape {
public:
    virtual void draw() { std::cout << "Drawing shape" << std::endl; }
};

class Circle : public Shape {
public:
    void draw() override { std::cout << "Drawing circle" << std::endl; }
};

Shape* s = new Circle();
s->draw();  // Décidé à l'exécution : "Drawing circle"

Le compromis essentiel : le polymorphisme à la compilation n'entraîne aucune surcharge à l'exécution, puisque les décisions sont prises lors de la compilation, tandis que le polymorphisme à l'exécution ajoute un léger coût (recherche dans la vtable), mais offre une plus grande flexibilité pour travailler avec des objets dont les types ne sont pas connus avant l'exécution.

Défi

Facile

Construisons un système de calculatrice qui démontre les deux types de polymorphisme côte à côte. Tu vas créer un système dans lequel le polymorphisme à la compilation gère différents types d’entrée grâce à la surcharge de fonctions, tandis que le polymorphisme à l’exécution permet de remplacer dynamiquement différentes stratégies de calcul.

Tu organiseras ton code sur trois fichiers :

Calculator.h : définir une classe de base Calculator qui représente toute stratégie de calcul :
- une méthode virtuelle calculate(int a, int b) qui renvoie un int et affiche : Base calculation: <a> ? <b> (en renvoyant 0)
- un destructeur virtuel
Operations.h : définir deux classes de calculatrice dérivées qui redéfinissent le comportement du calcul :
- Adder : redéfinir calculate() pour afficher Adding: <a> + <b> et renvoyer la somme
- Multiplier : redéfinir calculate() pour afficher Multiplying: <a> * <b> et renvoyer le produit
Les deux classes doivent utiliser le mot-clé override.
main.cpp : créer un système qui présente les deux types de polymorphisme. Lire deux nombres entiers (chacun sur une ligne distincte).
Commence par démontrer le polymorphisme à la compilation en créant trois fonctions display() surchargées :
- display(int x) affiche : Integer value: <x>
- display(double x) affiche : Double value: <x>
- display(const std::string& x) affiche : String value: <x>
Démontre ensuite le polymorphisme à l’exécution en créant un tableau de pointeurs Calculator* contenant un Calculator de base, un Adder et un Multiplier. Parcours-le et appelle calculate() sur chacun avec tes valeurs d’entrée, en affichant le résultat après chaque calcul.

Structure ta sortie comme suit :
```
=== Compile-Time Polymorphism ===
<display outputs for int, double, string>

=== Runtime Polymorphism ===
<calculate outputs with results>
```
Pour la section de compilation, appelle display() avec la première entrée en tant qu’entier, puis en tant que nombre à virgule flottante (la même valeur avec .5 ajouté), puis en tant que chaîne "Result". Libère les calculatrices allouées dynamiquement lorsque tu as terminé.

Par exemple, avec les entrées 10 et 3 :

=== Compile-Time Polymorphism ===
Integer value: 10
Double value: 10.5
String value: Result

=== Runtime Polymorphism ===
Base calculation: 10 ? 3
Result: 0
Adding: 10 + 3
Result: 13
Multiplying: 10 * 3
Result: 30

Remarque comment le compilateur sélectionne la surcharge correcte de display() en fonction du type de l’argument (décision prise à la compilation), tandis que la méthode calculate() correcte est déterminée par le type réel de l’objet à l’exécution grâce au mécanisme de vtable.

Essayez vous-même

#include <iostream>
#include <string>
#include "Calculator.h"
#include "Operations.h"

// TODO: Créez trois fonctions display() surchargées :
// 1. display(int x) - prints "Integer value: <x>"
// 2. display(double x) - affiche "Double value: <x>"
// 3. display(const std::string& x) - affiche "String value: <x>"



int main() {
    // Lire deux entrées entières
    int a, b;
    std::cin >> a;
    std::cin >> b;
    
    // === Compile-Time Polymorphism ===
    std::cout << "=== Compile-Time Polymorphism ===" << std::endl;
    // TODO: Appelez display() avec :
    // - a en tant qu'entier
    // - a en tant que double (ajoutez 0.5 à celui-ci)
    // - la chaîne "Result"
    
    
    std::cout << std::endl;
    
    // === Runtime Polymorphism ===
    std::cout << "=== Runtime Polymorphism ===" << std::endl;
    // TODO: Créez un tableau de pointeurs Calculator* avec 3 éléments :
    // - a base Calculator
    // - un Adder
    // - un Multiplier
    
    // TODO: Parcourez le tableau, appelez calculate(a, b) sur chacun,
    // et affiche "Result: <return_value>" après chaque calcul
    
    
    // TODO: Nettoyer la mémoire allouée dynamiquement
    
    
    return 0;
}