Redéfinition des méthodes

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

La redéfinition de méthode se produit lorsqu'une classe dérivée fournit sa propre implémentation d'une méthode qui existe déjà dans la classe de base. Cela permet aux classes dérivées de personnaliser le comportement hérité tout en conservant la même signature de méthode.

Pour redéfinir une méthode, définissez simplement une méthode dans la classe dérivée avec exactement le même nom, le même type de retour et les mêmes paramètres :

class Animal {
public:
    void speak() {
        std::cout << "Some sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() {
        std::cout << "Woof!" << std::endl;
    }
};

Dog d;
d.speak();  // Sortie : Woof!

La version de la classe dérivée masque la version de la classe de base. Cependant, vous pouvez toujours accéder à la méthode de la classe de base en utilisant l'opérateur de résolution de portée :

class Dog : public Animal {
public:
    void speak() {
        Animal::speak();  // Appeler la version de la classe de base
        std::cout << "Woof!" << std::endl;
    }
};

Il existe une limitation importante avec cette forme de base de redéfinition (overriding). Lorsque vous accédez à un objet dérivé via un pointeur ou une référence de classe de base, c'est la version de la classe de base qui est appelée à la place :

Dog d;
Animal* ptr = &d;
ptr->speak();  // Résultat : Some sound (pas Woof !)

Cela se produit parce que le compilateur détermine quelle méthode appeler en se basant sur le type du pointeur, et non sur le type réel de l'objet. Pour parvenir à un véritable polymorphisme d'exécution où la méthode correcte est appelée en fonction de l'objet réel, vous aurez besoin de fonctions virtuelles, que nous aborderons dans la prochaine leçon.

Défi

Facile

Construisons un système de notifications qui illustre la redéfinition de méthodes en action. Vous allez créer une classe de base Notifier et deux notificateurs spécialisés qui personnalisent la manière dont les messages sont transmis.

Vous organiserez votre code sur trois fichiers :

Notifier.h : définissez une classe de base Notifier avec :
- un membre protégé std::string recipient
- un constructeur qui accepte un nom de destinataire et le stocke
- une méthode publique send(const std::string& message) qui affiche : Sending to <recipient>: <message>
EmailNotifier.h : définissez une classe EmailNotifier qui hérite publiquement de Notifier :
- un constructeur qui accepte un destinataire et le transmet à la classe de base
- redéfinissez la méthode send() pour appeler d'abord la version de la classe de base à l'aide de Notifier::send(), puis afficher : [Email sent successfully]
main.cpp : lisez deux entrées (chacune sur une ligne distincte) :
1. Nom du destinataire (chaîne de caractères)
2. Contenu du message (chaîne de caractères)
Définissez une classe SMSNotifier directement dans main.cpp qui hérite publiquement de Notifier :
- un constructeur qui accepte un destinataire et le transmet à la classe de base
- redéfinissez la méthode send() pour afficher : SMS to <recipient>: <message> (en remplaçant complètement le comportement de base sans l'appeler)
Créez un objet de chaque type de notificateur (Notifier de base, EmailNotifier et SMSNotifier) en utilisant le même destinataire. Appelez send() sur chacun avec le message saisi, en affichant une ligne de séparation entre chacun :
```
--- Base Notifier ---
<output>
--- Email Notifier ---
<output>
--- SMS Notifier ---
<output>
```

Par exemple, avec les entrées Alice et Hello there! :

--- Base Notifier ---
Sending to Alice: Hello there!
--- Email Notifier ---
Sending to Alice: Hello there!
[Email sent successfully]
--- SMS Notifier ---
SMS to Alice: Hello there!

Remarquez comment EmailNotifier étend le comportement de base en appelant d'abord la méthode parente, tandis que SMSNotifier la remplace complètement par sa propre implémentation. N'oubliez pas les gardes d'inclusion et d'inclure les en-têtes appropriés dans chaque fichier.

Essayez vous-même

#include <iostream>
#include <string>
#include "Notifier.h"
#include "EmailNotifier.h"

using namespace std;

// TODO: Définir la classe SMSNotifier ici qui hérite publiquement de Notifier
// - Constructeur qui passe recipient à la classe de base
// - Surcharger send() pour afficher : SMS to <recipient>: <message>
//   (remplacer complètement le comportement de base, ne pas appeler le send() parent)

int main() {
    string recipient;
    string message;
    
    getline(cin, recipient);
    getline(cin, message);
    
    // TODO: Créer un objet Notifier avec recipient
    // Afficher "--- Base Notifier ---"
    // Appeler send() avec message
    
    // TODO: Créer un objet EmailNotifier avec recipient
    // Afficher "--- Email Notifier ---"
    // Appeler send() avec message
    
    // TODO: Créer un objet SMSNotifier avec recipient
    // Afficher "--- SMS Notifier ---"
    // Appeler send() avec message
    
    return 0;
}