Niveaux d’accès de l’héritage

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

Le type d’inheritance que vous choisissez détermine la manière dont les membres de la Base sont accessibles dans la classe Derived. C++ propose trois options : l’inheritance public, protected et private.

Voici comment chaque type transforme l'accès aux membres :

Membre de base	héritage public	héritage protected	héritage privé
public	public	protected	private
protected	protected	protected	private
private	inaccessible	inaccessible	inaccessible

class Base {
public:
    int pub;
protected:
    int prot;
private:
    int priv;
};

class PublicDerived : public Base {
    // pub est public, prot est protected, priv est inaccessible
};

class ProtectedDerived : protected Base {
    // pub est protected, prot est protected, priv est inaccessible
};

class PrivateDerived : private Base {
    // pub est private, prot est private, priv est inaccessible
};

L’héritage public modélise les relations « est-un » et est de loin le plus courant. Un Dog est un Animal, le code externe peut donc le traiter comme tel.

L’héritage protégé et privé modélise les relations « implémenté en termes de ». Il masque l’interface de la classe de base au code externe, ce qui est utile lorsque vous souhaitez réutiliser l’implémentation sans exposer la relation d’héritage. Avec l’héritage privé, même les classes dérivées ultérieurement perdent l’accès aux membres de la classe de base d’origine.

Défi

Facile

Explorons comment les différents types d’héritage affectent l’accessibilité des membres en construisant une hiérarchie simple d’appareils. Tu vas créer une classe de base Device et trois classes dérivées, chacune utilisant un type d’héritage différent, afin de voir concrètement comment les héritages public, protégé et privé transforment l’accès aux membres.

Tu organiseras ton code sur deux fichiers :

Device.h : définis une classe de base Device avec trois membres ayant différents niveaux d’accès :
- Un std::string model public
- Un int serialNumber protégé
- Un int internalCode privé (défini par défaut à 999)
- Une méthode publique showModel() qui affiche : Model: <model>
Crée ensuite trois classes dérivées qui héritent chacune de Device en utilisant un type d’héritage différent :
- PublicDevice avec un héritage public : ajoute une méthode displaySerial() qui affiche : Serial: <serialNumber>
- ProtectedDevice avec un héritage protégé : ajoute une méthode displaySerial() qui affiche : Serial: <serialNumber>
- PrivateDevice avec un héritage privé : ajoute une méthode displaySerial() qui affiche : Serial: <serialNumber>
Chaque classe dérivée doit avoir un constructeur qui prend un nom de modèle et un numéro de série, transmet le modèle à la classe de base et définit le numéro de série.
main.cpp : lis deux entrées (chacune sur une ligne distincte) :
1. Nom du modèle (chaîne de caractères)
2. Numéro de série (entier)
Crée un objet de chaque type dérivé avec les mêmes valeurs d’entrée. Démontre ensuite les différences d’accès :

Pour PublicDevice :
- Appelle directement showModel() sur l’objet (cela fonctionne, car l’héritage public le conserve comme membre public)
- Accède directement à model et affiche : Direct model access: <model>
- Appelle displaySerial()
Pour ProtectedDevice et PrivateDevice :
- Appelle uniquement displaySerial() (showModel() et model hérités ne sont plus accessibles publiquement depuis l’extérieur)
Format de sortie :
```
--- PublicDevice ---
Model: <model>
Direct model access: <model>
Serial: <serial>
--- ProtectedDevice ---
Serial: <serial>
--- PrivateDevice ---
Serial: <serial>
```

Par exemple, avec les entrées Laptop et 12345 :

--- PublicDevice ---
Model: Laptop
Direct model access: Laptop
Serial: 12345
--- ProtectedDevice ---
Serial: 12345
--- PrivateDevice ---
Serial: 12345

Remarque que seul PublicDevice autorise l’accès externe aux membres publics hérités. Les autres types d’héritage masquent l’interface de la classe de base vis-à-vis du code externe, mais les classes dérivées peuvent toujours accéder aux membres protégés en interne par l’intermédiaire de leurs propres méthodes.

Essayez vous-même

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

using namespace std;

int main() {
    // Lire l'entrée
    string modelName;
    int serialNum;
    
    getline(cin, modelName);
    cin >> serialNum;
    
    // TODO: Créer des objets de chaque type dérivé avec les valeurs d'entrée
    // PublicDevice pubDev(modelName, serialNum);
    // ProtectedDevice protDev(modelName, serialNum);
    // PrivateDevice privDev(modelName, serialNum);
    
    // TODO: Demonstrate PublicDevice access
    cout << "--- PublicDevice ---" << endl;
    // - Appeler showModel() directement sur l'objet
    // - Access model directly and print: Direct model access: <model>
    // - Appeler displaySerial()
    
    // TODO: Demonstrate ProtectedDevice access
    cout << "--- ProtectedDevice ---" << endl;
    // - Appeler uniquement displaySerial() (showModel et model ne sont pas accessibles publiquement)
    
    // TODO: Demonstrate PrivateDevice access
    cout << "--- PrivateDevice ---" << endl;
    // - Appeler uniquement displaySerial() (showModel et model ne sont pas accessibles publiquement)
    
    return 0;
}