Polymorphism et fonctions virtuelles

Le polymorphisme (polymorphism) permet de traiter des objets de différentes classes dérivées via un pointeur ou une référence vers leur classe de base, garantissant ainsi l'exécution de la version correcte de chaque méthode lors de l'exécution (Late Binding).

Fonctions virtuelles : virtual et override

Pour activer le polymorphisme sur une méthode, nous devons la déclarer avec le mot-clé virtual dans la classe de base. Dans les classes dérivées, nous utilisons le spécificateur override pour indiquer explicitement que nous redéfinissons cette méthode.

class Employee {
public:
    virtual void work() {
        std::cout << "Lavoro generico" << std::endl;
    }
    // IMPORTANT : Destructeur virtuel dans la classe de base pour éviter les fuites de mémoire
    virtual ~Employee() = default;
};

class Developer : public Employee {
public:
    void work() override {
        std::cout << "Scrittura codice in C++" << std::endl;
    }
};

Utilisant des pointeurs vers la classe de base, C++ résoudra la méthode correcte lors de l'exécution :

Employee* emp = new Developer();
emp->work(); // Stampa "Scrittura codice in C++" invece di "Lavoro generico"
delete emp;

Classes abstraites et fonctions virtuelles pures

Une fonction virtuelle pure est une fonction membre virtuelle déclarée avec = 0 à la fin. Elle représente un contrat formel : la classe de base ne fournit aucune implémentation, la déléguant entièrement aux sous-classes.

Une classe qui contient au moins une fonction virtuelle pure est appelée classe abstraite et ne peut pas être instanciée directement.

class Instrument {
public:
    virtual void play() = 0; // Virtuale pura
    virtual ~Instrument() = default;
};

class Piano : public Instrument {
public:
    void play() override {
        std::cout << "Suono del pianoforte..." << std::endl;
    }
};

À vous de jouer