Héritage de base

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

L'héritage permet à une classe d'acquérir les propriétés et les comportements d'une autre classe. La classe dont on hérite est appelée la classe de base (ou parent), et la classe qui hérite est appelée la classe dérivée (ou enfant).

Pour créer une classe dérivée, utilisez deux-points suivis du spécificateur d'accès et du nom de la classe de base :

class Animal {
public:
    std::string name;
    
    void eat() {
        std::cout << name << " is eating" << std::endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        std::cout << name << " says woof!" << std::endl;
    }
};

La classe Dog a maintenant accès à la fois à name et eat() de Animal, ainsi qu'à sa propre méthode bark(). C'est l'essence même de l'héritage : réutiliser le code existant tout en ajoutant de nouvelles fonctionnalités.

Dog myDog;
myDog.name = "Buddy";
myDog.eat();    // Hérité de Animal
myDog.bark();   // Défini dans Dog

Le mot-clé public avant Animal spécifie le type d’héritage. L’héritage public signifie que les membres publics de la classe de base restent publics dans la classe dérivée. Il s’agit de la forme la plus courante et elle modélise une relation « est-un » : un Dog est un Animal.

Défi

Facile

Construisons une hiérarchie de véhicules simple qui montre l’héritage en action. Vous allez créer une classe de base Vehicle et une classe dérivée Motorcycle qui l’étend avec un comportement spécialisé.

Vous allez organiser votre code sur trois fichiers :

Vehicle.h : définissez une classe de base Vehicle avec :
- un membre public std::string brand
- un membre public int year
- une méthode publique displayInfo() qui affiche la marque et l’année du véhicule au format : Brand: <brand>, Year: <year>
Motorcycle.h : définissez une classe Motorcycle qui hérite publiquement de Vehicle. Cette classe dérivée doit ajouter :
- un membre public int engineCC pour la cylindrée du moteur
- une méthode publique revEngine() qui affiche : <brand> goes vroom vroom!
La classe Motorcycle héritera automatiquement de brand les membres year et displayInfo(), ainsi que la méthode Vehicle.
main.cpp : lisez trois entrées (chacune sur une ligne distincte) :
1. Nom de la marque (chaîne de caractères)
2. Année (entier)
3. Cylindrée du moteur en CC (entier)
Créez un objet Motorcycle, définissez ses membres hérités (brand et year) ainsi que son propre membre engineCC. Produisez ensuite les trois lignes de sortie dans l’ordre : appelez d’abord la méthode héritée displayInfo(), affichez ensuite vous-même la cylindrée avec std::cout << "Engine: " << moto.engineCC << "cc" << std::endl;, puis appelez enfin la méthode spécifique à la moto revEngine(). Cela démontre l’héritage en utilisant à la fois la méthode héritée et la propre méthode de la classe dérivée.

Format de sortie :
```
Brand: <brand>, Year: <year>
Engine: <engineCC>cc
<brand> goes vroom vroom!
```

Par exemple, avec les entrées Harley, 2022 et 1200 :

Brand: Harley, Year: 2022
Engine: 1200cc
Harley goes vroom vroom!

N’oubliez pas d’inclure des protections contre les inclusions multiples dans vos fichiers d’en-tête et d’utiliser #include "Vehicle.h" dans votre en-tête Motorcycle pour accéder à la classe de base.

Essayez vous-même

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

using namespace std;

int main() {
    string brand;
    int year;
    int engineCC;

    cin >> brand;
    cin >> year;
    cin >> engineCC;

    // TODO : Créer un objet Motorcycle
    // TODO : Définir ses membres brand, year et engineCC
    // TODO : Appeler displayInfo() pour afficher les informations héritées
    // TODO : Imprimer les informations du moteur au format : Engine: <engineCC>cc
    // TODO : Appeler revEngine() pour démontrer le comportement spécifique à la moto

    return 0;
}