Apprendre C/C++ Étape par Étape - Page 14

14. Étape par Étape C/C++ — Programmation C++ - Héritage

Héritage

| | Introduction
Classe dérivée et Classe de base
Spécification de la Classe Dérivée
Constructeurs de Classe Dérivée
Spécificateurs d’Accès
Public
Privé
Protégé
Spécificateurs d’Accès sans Héritage
Spécificateur d’Accès Protégé
Portée des Spécificateurs d’Accès
Spécificateurs d’Accès avec Héritage
Types d’Héritage
Héritage Simple
Héritages Multiples
Héritage Multiniveau
Héritage Hybride
Héritage Hiérarchique |

Introduction

L’héritage est la fonctionnalité la plus puissante de la programmation orientée objet. L’héritage est le processus de création de nouvelles classes, appelées classes dérivées, à partir de classes existantes ou de classes de base. La classe dérivée hérite de toutes les capacités de la classe de base mais peut ajouter des embellissements et des raffinements propres.
Une classe, appelée classe dérivée, peut hériter des caractéristiques d’une autre classe, appelée classe de base.

Hériter des qualités de la classe de base à la classe dérivée est connu sous le nom d’héritage .
Son nom est héritage. Nous savons dans notre vie quotidienne que nous utilisons le concept de classes dérivées en sous-classes. Par exemple, le véhicule est une classe qui est à nouveau divisée en cycles, motos, autos, camions, bus, etc.

Ici, le véhicule est connu comme la classe de base et les éléments dérivés sont connus comme des classes dérivées ou des sous-classes. **

En général, chaque classe de base a une liste de qualités et de caractéristiques. Le thème principal de cet héritage est de partager toutes les caractéristiques communes de la classe de base avec les classes dérivées.

| | |

L’héritage a une fonctionnalité importante qui permet la réutilisation. Un résultat de la réutilisation est la facilité de distribution des bibliothèques de classes. Un programmeur peut utiliser une classe créée par une autre personne ou entreprise, et, sans la modifier, dériver d’autres classes à partir de celle-ci qui sont adaptées à des situations particulières.

Classe Dérivée et Classe de Base

Une classe, appelée classe dérivée, peut hériter des caractéristiques d’une autre classe, appelée classe de base.
La classe dérivée peut ajouter d’autres caractéristiques propres, devenant ainsi une version spécialisée de la classe de base. L’héritage fournit un moyen puissant d’étendre les capacités des classes existantes et de concevoir des programmes utilisant des relations hiérarchiques.

L’accessibilité des membres de la classe de base depuis les classes dérivées et depuis les objets des classes dérivées est un problème important. Les objets des classes dérivées peuvent accéder aux données ou aux fonctions de la classe de base qui sont précédées du mot-clé protégé des classes dérivées mais pas. Les classes peuvent être dérivées publiquement ou privément des classes de base. Les objets d’une classe dérivée publiquement peuvent accéder aux membres publics de la classe de base, tandis que les objets d’une classe dérivée privément ne le peuvent pas.

Le diagramme montre comment la classe dérivée hérite.

| | |

Une classe peut être dérivée de plus d’une classe de base. Cela s’appelle des héritages multiples. Une classe peut également être contenue dans une autre classe.

Spécification de la Classe Dérivée

La déclaration de classe est si facile en utilisant le mot-clé class ainsi que la déclaration de la classe dérivée est également facile mais la classe doit se terminer par son identifiant de classe de base et le spécificateur d’accès.
Syntaxe pour déclarer une classe dérivée :

Class lass_name>: ….

Par exemple, class result : public stud;

| | / programme pour accepter et afficher un enregistrement d’étudiant /
#include
using namespace std;
class add
{
private :
char str[20];
char city[20];
int pin;
public :
void get_add()
{
cout << “Entrez l’adresse rue, ville, code postal”;
cin >> street >>city>>pin;
}
void put_data()
{
cout << “L’adresse est “ << str
<}
};
class stud : public add
{
private :
int sno;
char name[20];
int m1,m2,m3;
public :
void get_data()
{
cout << “Entrez le numéro d’étudiant “; cin >> sno;
cout << “Entrez le nom de l’étudiant “; cin >> name;
cout << “Entrez les notes de 3 matières de l’étudiant “;
cin >> m1 << m2 << m3;
}
void put_data()
{
cout << “Numéro d’étudiant :” << sno;
cout << “Nom de l’étudiant :” << name;
cout << “Notes de l’étudiant :” << m1 << “ “ <}
};
int main()
{
stud s;
s.get_add();
s.get_data();
s.put_add();
s.put_data();
return 0;
} |

Explication diagrammée pour le programme ci-dessus

| | |

Constructeurs de Classe Dérivée

Si une classe est déclarée avec ses propres constructeurs, elle est une classe de base d’une autre. La classe dérivée a également ses propres constructeurs. Si un objet est déclaré, quel constructeur sera exécuté ? Pas de doute, c’est le constructeur de la classe dérivée qui sera exécuté. Si vous souhaitez toujours exécuter le constructeur de la classe de base ou les constructeurs de la classe dérivée et de la classe de base, appelez simplement le constructeur de la classe de base dans le constructeur de la classe dérivée.

| | / Constructeurs dans la classe dérivée /
#include
using namespace std;
class Add
{
protected : // REMARQUE : pas privé
unsigned int a;
public :
Add() { a = 0; } // constructeur, pas d’arguments
Add( int c ) { a = c; } // constructeur, un argument
int get_val(){ return a; } // retourne la valeur A
Add operator ++ () // incrémente le compte
{
a++; // incrémente le compte, retourne
return Add(a); // un objet temporaire sans nom
} // initialisé à ce compte
};

class Sub : public Add
{
public:
Sub() : Add() { } // Constructeur, pas d’arguments
Sub(int c) : Add(c) { } // Constructeur, un argument
Sub operator – () // décrémente la valeur de A, retourne
{ // un objet temporaire sans nom
a–; // initialisé à cette valeur
return Sub(a);
}
};
int main()
{
Sub ob1; // classe Sub
Sub ob2(100);
cout << “\nOb1 =” << ob1.get_val(); // afficher
cout << “\nOb2 =” << ob2.get_val(); // afficher
ob1++; ob1++; ob1++; // incrémente ob1
cout << “\nOb1 =” << ob1.get_val(); // afficher
ob2–; ob2–; // décrémente ob2
cout << “\nOb2 =” << ob2.get_val(); // afficher
Sub ob3=ob2–; // créer ob3 à partir d’ob2
cout << “\nOb3 =” << ob3.get_val(); // afficher
return 0;
} |

SPÉCIFICATEURS D’ACCÈS

Les spécificateurs d’accès sont utilisés pour contrôler, cacher, sécuriser à la fois les données et les fonctions membres. Les spécificateurs d’accès sont de 3 types

1. Spécificateur d’Accès Public
2. Spécificateur d’Accès Privé
3. Spécificateur d’Accès Protégé.

Public :

| | Si un membre ou une donnée est public, il peut être utilisé par n’importe quelle fonction dans la classe et ses classes dérivées également.
Dans C++, les membres d’un struct ou union sont publics par défaut.
Les membres publics d’une classe peuvent être hérités par la classe dérivée lorsque la classe est héritée publiquement mais pas les fonctions membres (privément). |

Privé :

| | Les fonctions membres et les amis de la classe dans laquelle elle est déclarée peuvent seulement l’utiliser.
Les membres d’une classe sont privés par défaut.
Les membres privés d’une classe ne sont pas hérités par une classe dérivée lorsque la classe de base est héritée publiquement ou privément. S’il y a besoin, nous devons écrire des fonctions membres, qui retournent ces valeurs. |

Protégé :

| | C’est l’accès comme pour privé, de plus, le membre peut être utilisé par les fonctions membres et les amis des classes dérivées de la classe déclarée mais pas seulement dans les objets du type dérivé.
Le membre protégé d’une classe peut être hérité par la prochaine classe dérivée seulement. Mais pas par les classes ultérieures. |

Spécificateurs d’Accès sans Héritage

| | |

Plus d’Informations sur le Spécificateur d’Accès Protégé

Pour fournir la fonctionnalité sans modifier la classe. Protégé peut être accédé par lui-même et les membres protégés de la classe dérivée seulement mais dans les objets ou la sous-classe dérivée ou la classe extérieure.

Portée des Spécificateurs d’Accès

| Spécificateur d’Accès | Accessible depuis
La classe propre | Accessible depuis
la classe dérivée | Accessible depuis
Objets en dehors de la classe | | Public | Oui | Oui | Oui | | Protégé | Oui | Oui | Non | | Privé | Oui | Non | Non |

Spécificateurs d’Accès avec Héritage

| | |

Types d’Héritage

| | |

| | |

| | / Programme pour démontrer l’Héritage Multiple /
#include
using namespace std;
class M
{
protected :
int m;
public :
void getm()
{
cout << “\nEntrez la valeur M :”;
cin >> m;
}
};
class N
{
protected :
int n;
public :
void getn()
{
cout << “\nEntrez la valeur N :”;
cin >> n;
}
};
class P : public N, public M
{
public :
void disp()
{
cout << “\n M = “ << m;
cout << “\n N = “ << n;
cout << “\n MN = “ << mn;
}
};
int main()
{
P p;
p.getm();
p.getn();
p.disp();
return 0;
} |

Si une classe de base est héritée publiquement, alors les membres publics, les fonctions membres peuvent être accessibles aux fonctions membres de la classe dérivée et aux objets également, tandis que si une classe de base est héritée privément, alors les membres publics de la classe de base sont hérités par les fonctions membres de la classe dérivée seulement mais pas par les objets.

| | / Un programme pour démontrer l’Héritage Multiniveau /
class student
{
int rno;
public:
void getrno()
{
cout << “Entrez le numéro :”;
cin >> rno;
}
void showrno()
{
cout << “Numéro d’étudiant:” << rno;
}
};
class test : public student
{
int m1,m2;
public :
void getmarks()
{
cout << “Entrez les notes 1 :