Maîtriser l'héritage C++ : Public, Protected et Private expliqués

Héritage public, protected et private en C++

Dans ce tutoriel, nous apprendrons à utiliser l'héritage public, protected et private en C++ avec des exemples.

En héritage C++, nous pouvons dériver une classe enfant de la classe de base dans différents modes d'accès. Par exemple,

class Base {
    .... ... ....
};
class Derived : public Base {
    .... ... ....
};

Remarquez le mot-clé public dans le code

class Derived : public Base

Cela signifie que nous avons créé une classe dérivée de la classe de base en mode public. Alternativement, nous pouvons aussi dériver des classes en mode protected ou private.

Ces 3 mots-clés (public, protected et private) sont connus sous le nom de spécificateurs d'accès en héritage C++.

---

Héritage public, protected et private en C++

public, protected et private héritage ont les caractéristiques suivantes :

• Héritage public rend les membres public de la classe de base public dans la classe dérivée, et les membres protected de la classe de base restent protected dans la classe dérivée.
• Héritage protected rend les membres public et protected de la classe de base protected dans la classe dérivée.
• Héritage private rend les membres public et protected de la classe de base private dans la classe dérivée.

Note : Les membres private de la classe de base sont inaccessibles à la classe dérivée.

class Base {
public:
    int x;
protected:
    int y;
private:
    int z;
};

class PublicDerived: public Base {
    // x est public
    // y est protected
    // z n'est pas accessible depuis PublicDerived
};

class ProtectedDerived: protected Base {
    // x est protected
    // y est protected
    // z n'est pas accessible depuis ProtectedDerived
};

class PrivateDerived: private Base {
    // x est private
    // y est private
    // z n'est pas accessible depuis PrivateDerived
}

---

Exemple 1 : Héritage public en C++

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

class Base {
private:
    int pvt = 1;
protected:
    int prot = 2;
public:
    int pub = 3;
    // fonction pour accéder au membre private
    int getPVT() {
        return pvt;
    }
};

class PublicDerived : public Base {
public:
    // fonction pour accéder au membre protected depuis Base
    int getProt() {
        return prot;
    }
};

int main() {
    PublicDerived object1;
    cout << "Private = " << object1.getPVT() << endl;
    cout << "Protected = " << object1.getProt() << endl;
    cout << "Public = " << object1.pub << endl;
    return 0;
}

Sortie

Private = 1 Protected = 2 Public = 3

Ici, nous avons dérivé PublicDerived de Base en mode public.

En conséquence, dans PublicDerived :

• prot est hérité comme protected.
• pub et getPVT() sont hérités comme public.
• pvt est inaccessible car il est private dans Base.

Puisque les membres private et protected ne sont pas accessibles depuis main(), nous devons créer des fonctions publiques getPVT() et getProt() pour y accéder :

// Erreur : le membre "Base::pvt" est inaccessible
cout << "Private = " << object1.pvt;
// Erreur : le membre "Base::prot" est inaccessible
cout << "Protected = " << object1.prot;

Remarquez que la fonction getPVT() a été définie à l'intérieur de Base. Mais la fonction getProt() a été définie à l'intérieur de PublicDerived.

C'est parce que pvt, qui est private dans Base, est inaccessible à PublicDerived.

Cependant, prot est accessible à PublicDerived grâce à l'héritage public. Donc, getProt() peut accéder à la variable protected depuis l'intérieur de PublicDerived.

---

Accessibilité en héritage public

Accessibilité	Membres private	Membres protected	Membres public
Classe de base	Oui	Oui	Oui
Classe dérivée	Non	Oui	Oui

---

Exemple 2 : Héritage protected en C++

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

class Base {
private:
    int pvt = 1;
protected:
    int prot = 2;
public:
    int pub = 3;
    // fonction pour accéder au membre private
    int getPVT() {
        return pvt;
    }
};

class ProtectedDerived : protected Base {
public:
    // fonction pour accéder au membre protected depuis Base
    int getProt() {
        return prot;
    }
    // fonction pour accéder au membre public depuis Base
    int getPub() {
        return pub;
    }
};

int main() {
    ProtectedDerived object1;
    cout << "Private ne peut pas être accédé." << endl;
    cout << "Protected = " << object1.getProt() << endl;
    cout << "Public = " << object1.getPub() << endl;
    return 0;
}

Sortie

Private ne peut pas être accédé. Protected = 2 Public = 3

Ici, nous avons dérivé ProtectedDerived de Base en mode protected.

En conséquence, dans ProtectedDerived :

• prot, pub et getPVT() sont hérités comme protected.
• pvt est inaccessible car il est private dans Base.

Comme nous le savons, les membres protected ne peuvent pas être directement accédés depuis l'extérieur de la classe. En conséquence, nous ne pouvons pas utiliser getPVT() depuis ProtectedDerived.

C'est aussi pourquoi nous devons créer la fonction getPub() dans ProtectedDerived afin d'accéder à la variable pub.

// Erreur : le membre "Base::getPVT()" est inaccessible
cout << "Private = " << object1.getPVT();
// Erreur : le membre "Base::pub" est inaccessible
cout << "Public = " << object1.pub;

---

Accessibilité en héritage protected

Accessibilité	Membres private	Membres protected	Membres public
Classe de base	Oui	Oui	Oui
Classe dérivée	Non	Oui	Oui (hérités comme variables protected)

---

Exemple 3 : Héritage private en C++

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

class Base {
private:
    int pvt = 1;
protected:
    int prot = 2;
public:
    int pub = 3;
    // fonction pour accéder au membre private
    int getPVT() {
        return pvt;
    }
};

class PrivateDerived : private Base {
public:
    // fonction pour accéder au membre protected depuis Base
    int getProt() {
        return prot;
    }
    // fonction pour accéder au membre private
    int getPub() {
        return pub;
    }
};

int main() {
    PrivateDerived object1;
    cout << "Private ne peut pas être accédé." << endl;
    cout << "Protected = " << object1.getProt() << endl;
    cout << "Public = " << object1.getPub() << endl;
    return 0;
}

Sortie

Private ne peut pas être accédé. Protected = 2 Public = 3

Ici, nous avons dérivé PrivateDerived de Base en mode private.

En conséquence, dans PrivateDerived :

• prot, pub et getPVT() sont hérités comme private.
• pvt est inaccessible car il est private dans Base.

Comme nous le savons, les membres private ne peuvent pas être directement accédés depuis l'extérieur de la classe. En conséquence, nous ne pouvons pas utiliser getPVT() depuis PrivateDerived.

C'est aussi pourquoi nous devons créer la fonction getPub() dans PrivateDerived afin d'accéder à la variable pub.

// Erreur : le membre "Base::getPVT()" est inaccessible
cout << "Private = " << object1.getPVT();
// Erreur : le membre "Base::pub" est inaccessible
cout << "Public = " << object1.pub;

---

Accessibilité en héritage private

Accessibilité	Membres private	Membres protected	Membres public
Classe de base	Oui	Oui	Oui
Classe dérivée	Non	Oui (hérités comme variables private)	Oui (hérités comme variables private)