Niveaux d'accès à 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'héritage que vous choisissez affecte la façon dont les membres de la classe de base sont accessibles dans la classe dérivée. C++ propose trois options : l'héritage 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 private
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 protégé, priv est inaccessible
};

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

class PrivateDerived : private Base {
    // pub est privé, prot est privé, 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, donc le code externe peut le traiter comme tel.

L'héritage protégé et privé modélise des relations de type "implémenté en termes de". Ils masquent l'interface de la classe de base aux yeux du code externe, ce qui est utile lorsque vous souhaitez réutiliser une implémentation sans exposer la relation d'héritage. Avec l'héritage privé, les classes dérivées plus poussées perdent même l'accès aux membres de base d'origine.

Défi

Facile

Explorons comment les différents types d'inheritance affectent l'accessibilité des membres en construisant une hiérarchie d'appareils simple. Vous allez créer une class de base Device et trois classes dérivées (derived), chacune utilisant un type d'inheritance différent, pour voir directement comment l'inheritance public, PROTECTED et PRIVATE transforme l'Access aux membres.

Vous organiserez votre code dans deux fichiers :

Device.h : Définissez une class de base Device avec trois membres à des niveaux d'Access différents :
- Un std::string model public
- Un int serialNumber protected
- Un int internalCode private (défini à 999 par défaut)
- Une method public showModel() qui prints : Model: <model>
Ensuite, créez trois classes dérivées (derived) qui héritent chacune de Device en utilisant différents types d'inheritance :
- PublicDevice utilisant l'inheritance public — ajoutez une method displaySerial() qui prints : Serial: <serialNumber>
- ProtectedDevice utilisant l'inheritance protected — ajoutez une method displaySerial() qui prints : Serial: <serialNumber>
- PrivateDevice utilisant l'inheritance private — ajoutez une method displaySerial() qui prints : Serial: <serialNumber>
Chaque class derived doit avoir un Constructor qui prend un nom de model et un number de série, transmettant le model à la class Base et définissant le number de série.
main.cpp : Lisez deux entrées (input, chacune sur une ligne séparée) :
1. Nom du Model (string)
2. Numéro de série (integer)
Créez un object de chaque type derived avec les mêmes valeurs d'input. Ensuite, démontrez les différences d'Access :

Pour PublicDevice :
- Appelez (Call) showModel() directly sur l'object (fonctionne car l'inheritance public le maintient public)
- Accédez directly à model et imprimez : Direct model access: <model>
- Appelez displaySerial()
Pour ProtectedDevice et PrivateDevice :
- Appelez seulement (Only) displaySerial() (les membres hérités showModel() et model 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

Remarquez comment seul PublicDevice permet un Access externe aux membres publics hérités. Les autres types d'inheritance masquent l'interface de la class Base au code external, but les classes derived peuvent toujours accéder aux membres protected en interne via 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;
}