Maîtriser l'héritage en C++ : Construire des classes puissantes avec du code réutilisable

Héritage en C++

Dans ce tutoriel, nous apprendrons l'héritage en C++ avec l'aide d'exemples.

L'héritage est l'une des fonctionnalités clés de la programmation orientée objet en C++. Il nous permet de créer une nouvelle classe (classe dérivée) à partir d'une classe existante (classe de base).

La classe dérivée hérite des fonctionnalités de la classe de base et peut avoir des fonctionnalités supplémentaires qui lui sont propres. Par exemple,

class Animal {
    // fonction eat()
    // fonction sleep()
};
class Dog : public Animal {
    // fonction bark()
};

Ici, la classe Dog est dérivée de la classe Animal. Puisque Dog est dérivé de Animal, les membres de Animal sont accessibles à Dog.

Remarquez l'utilisation du mot-clé public lors de l'héritage de Dog depuis Animal.

class Dog : public Animal {...};

Nous pouvons aussi utiliser les mots-clés private et protected au lieu de public. Nous apprendrons les différences entre l'utilisation de private, public et protected plus loin dans ce tutoriel.

---

Relation est-un

L'héritage est une relation est-un. Nous utilisons l'héritage seulement si une relation est-un est présente entre les deux classes.

Voici quelques exemples :

• Une voiture est un véhicule.
• Une orange est un fruit.
• Un chirurgien est un médecin.
• Un chien est un animal.

---

Exemple 1 : Exemple simple d'héritage en C++

// Programme C++ pour démontrer l'héritage
#include <iostream>
using namespace std;

// classe de base
class Animal {
public:
    void eat() {
        cout << "Je peux manger !" << endl;
    }
    void sleep() {
        cout << "Je peux dormir !" << endl;
    }
};

// classe dérivée
class Dog : public Animal {
public:
    void bark() {
        cout << "Je peux aboyer ! Woof woof !! " << endl;
    }
};

int main() {
    // Création d'un objet de la classe Dog
    Dog dog1;
    // Appel des membres de la classe de base
    dog1.eat();
    dog1.sleep();
    // Appel du membre de la classe dérivée
    dog1.bark();
    return 0;
}

Sortie

Je peux manger !
Je peux dormir !
Je peux aboyer ! Woof woof !!

Ici, dog1 (l'objet de la classe dérivée Dog) peut accéder aux membres de la classe de base Animal. C'est parce que Dog est hérité de Animal.

// Appel des membres de la classe Animal
dog1.eat();
dog1.sleep();

---

Membres protected en C++

Le modificateur d'accès protected est particulièrement pertinent quand il s'agit de l'héritage en C++.

Comme les membres private, les membres protected sont inaccessibles en dehors de la classe. Cependant, ils peuvent être accédés par les classes dérivées et les classes/fonctions amies.

Nous avons besoin des membres protected si nous voulons cacher les données d'une classe, mais que nous voulons quand même que ces données soient héritées par ses classes dérivées.

Pour en savoir plus sur protected, référez-vous à notre tutoriel sur les modificateurs d'accès C++.

---

Exemple 2 : Membres protected en C++

// Programme C++ pour démontrer les membres protected
#include <iostream>
#include <string>
using namespace std;

// classe de base
class Animal {
private:
    string color;
protected:
    string type;
public:
    void eat() {
        cout << "Je peux manger !" << endl;
    }
    void sleep() {
        cout << "Je peux dormir !" << endl;
    }
    void setColor(string clr) {
        color = clr;
    }
    string getColor() {
        return color;
    }
};

// classe dérivée
class Dog : public Animal {
public:
    void setType(string tp) {
        type = tp;
    }
    void displayInfo(string c) {
        cout << "Je suis un " << type << endl;
        cout << "Ma couleur est " << c << endl;
    }
    void bark() {
        cout << "Je peux aboyer ! Woof woof !! " << endl;
    }
};

int main() {
    // Création d'un objet de la classe Dog
    Dog dog1;
    // Appel des membres de la classe de base
    dog1.eat();
    dog1.sleep();
    dog1.setColor("noir");
    // Appel du membre de la classe dérivée
    dog1.bark();
    dog1.setType("mammifère");
    // Utilisation de getColor() de dog1 comme argument
    // getColor() retourne une donnée string
    dog1.displayInfo(dog1.getColor());
    return 0;
}

Sortie

Je peux manger !
Je peux dormir !
Je peux aboyer ! Woof woof !!
Je suis un mammifère
Ma couleur est noir

Ici, la variable type est protected et est donc accessible depuis la classe dérivée Dog. Nous pouvons le voir car nous avons initialisé type dans la classe Dog en utilisant la fonction setType().

D'un autre côté, la variable private color ne peut pas être initialisée dans Dog.

class Dog : public Animal {
public:
    void setColor(string clr) {
        // Erreur : le membre "Animal::color" est inaccessible
        color = clr;
    }
};

De plus, comme le mot-clé protected cache les données, nous ne pouvons pas accéder à type directement depuis un objet de la classe Dog ou Animal.

// Erreur : le membre "Animal::type" est inaccessible
dog1.type = "mammifère";

---

Modes d'accès en héritage C++

Dans nos tutoriels précédents, nous avons appris les spécificateurs d'accès C++ tels que public, private et protected.

Jusqu'à présent, nous avons utilisé le mot-clé public pour hériter une classe d'une classe de base préexistante. Cependant, nous pouvons aussi utiliser les mots-clés private et protected pour hériter des classes. Par exemple,

class Animal {
    // code
};
class Dog : private Animal {
    // code
};

class Cat : protected Animal {
    // code
};

Les différentes façons dont nous pouvons dériver des classes sont connues sous le nom de modes d'accès. Ces modes d'accès ont les effets suivants :

1. public : Si une classe dérivée est déclarée en mode public, alors les membres de la classe de base sont hérités par la classe dérivée tels qu'ils sont.
2. private : Dans ce cas, tous les membres de la classe de base deviennent des membres private dans la classe dérivée.
3. protected : Les membres public de la classe de base deviennent des membres protected dans la classe dérivée.

Les membres private de la classe de base sont toujours private dans la classe dérivée.

Pour en savoir plus, visitez notre tutoriel sur l'héritage public, private, protected en C++.

---

Redéfinition de fonction membre dans l'héritage

Supposons que la classe de base et la classe dérivée aient des fonctions membres avec le même nom et les mêmes arguments.

Si nous créons un objet de la classe dérivée et essayons d'accéder à cette fonction membre, la fonction membre dans la classe dérivée est invoquée au lieu de celle dans la classe de base.

La fonction membre de la classe dérivée redéfinit la fonction membre de la classe de base.

En savoir plus sur la redéfinition de fonction en C++.

---

Lecture recommandée : Héritage multiple en C++