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 manière dont les membres de la classe de base sont accessibles dans la classe dérivée. Le 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 protégé	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 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 de type « est un » (is-a) 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 de type « implémenté en termes de ». Ils masquent l'interface de la classe de base vis-à-vis du code extérieur, 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érieures perdent l'accès aux membres originaux de la classe de base.

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. Vous allez créer une classe de base Device et trois classes dérivées, chacune utilisant un type d'héritage différent, pour voir concrètement comment l'héritage public, protégé et privé transforme l'accès aux membres.

Vous organiserez votre code sur deux fichiers :

Device.h : Définissez une classe de base Device avec trois membres à différents niveaux d'accès :
- Un membre public std::string model
- Un membre protégé int serialNumber
- Un membre privé int internalCode (défini à 999 par défaut)
- Une méthode publique showModel() qui affiche : Model: <model>
Ensuite, créez trois classes dérivées qui héritent chacune de Device en utilisant différents types d'héritage :
- PublicDevice utilisant l'héritage public — ajoutez une méthode displaySerial() qui affiche : Serial: <serialNumber>
- ProtectedDevice utilisant l'héritage protégé — ajoutez une méthode displaySerial() qui affiche : Serial: <serialNumber>
- PrivateDevice utilisant l'héritage privé — ajoutez 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, en passant le modèle à la classe de base et en définissant le numéro de série.
main.cpp : Lisez deux entrées (chacune sur une ligne séparée) :
1. Nom du modèle (chaîne de caractères)
2. Numéro de série (entier)
Créez un objet de chaque type dérivé avec les mêmes valeurs d'entrée. Ensuite, démontrez les différences d'accès :

Pour PublicDevice :
- Appelez showModel() directement sur l'objet (cela fonctionne car l'héritage public le maintient public)
- Accédez directement à model et affichez : Direct model access: <model>
- Appelez displaySerial()
Pour ProtectedDevice et PrivateDevice :
- Appelez uniquement displaySerial() (les membres hérités showModel() et model ne sont plus accessibles publiquement de 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 accès externe aux membres publics hérités. Les autres types d'héritage masquent l'interface de la classe de base au code extérieur, mais les classes dérivées peuvent toujours accéder aux membres protégés en interne via leurs propres méthodes.

Aide-mémoire

Le C++ propose trois types d'héritage qui contrôlent la manière dont les membres de la classe de base sont accessibles dans les classes dérivées :

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 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 de type "est-un" (is-a) et constitue le type le plus courant. Le code externe peut accéder aux membres publics de la classe de base via la classe dérivée.

L'héritage protégé (protected) et privé (private) modélisent des relations de type "implémenté en termes de" (implemented-in-terms-of). Ils masquent l'interface de la classe de base vis-à-vis du code extérieur. Avec l'héritage privé, même les classes dérivées ultérieures perdent l'accès aux membres originaux de la base.

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: Démontrer l'accès à PublicDevice
    cout << "--- PublicDevice ---" << endl;
    // - Appeler showModel() directement sur l'objet
    // - Accéder à model directement et afficher : Direct model access: <model>
    // - Appeler displaySerial()
    
    // TODO: Démontrer l'accès à ProtectedDevice
    cout << "--- ProtectedDevice ---" << endl;
    // - Appeler uniquement displaySerial() (showModel et model ne sont pas accessibles publiquement)
    
    // TODO: Démontrer l'accès à PrivateDevice
    cout << "--- PrivateDevice ---" << endl;
    // - Appeler uniquement displaySerial() (showModel et model ne sont pas accessibles publiquement)
    
    return 0;
}