C ++ Héritage multiple
- Héritage unique
- Héritage multiple
- Héritage hiérarchique
- Héritage à plusieurs niveaux
- Héritage hybride
Ici, notre sujet de discussion est de multiples héritages.
Plusieurs héritages
L'héritage multiple se produit lorsque plus d'une classe fonctionne comme une classe parentale. Dans le langage de programmation C ++, nous pouvons dériver une classe de la classe de base, mais nous pouvons également dériver une classe de ces classes qui sont également dérivées d'une autre classe de base. Nous appelons ce genre d'héritage multiple héritage. Au cours de ce processus, certains problèmes se produisent également; Ceux-ci sont expliqués plus tard dans le guide.
But de l'héritage
L'héritage est l'une des approches utiles et importantes de la POO (programmation orientée objet). L'objectif principal de l'utilisation de l'héritage dans OOP ou C ++ est de permettre à l'utilisateur de réutiliser le code source. Au lieu d'écrire le même code plusieurs fois, nous pouvons simplement utiliser l'héritage pour hériter des propriétés d'une classe de base à la classe enfant. Cela réduit également la complexité du code source.
La syntaxe pour plusieurs héritages est:
classe 1
;
classe 2: public 1
;
classe 3: public 2
;
Pour hériter de n'importe quelle classe, le nom de la classe enfant est écrit sur le côté gauche, tandis que la classe parent est écrite sur le côté droit, et cela est séparé par un côlon. Dans la syntaxe ci-dessus, la classe 2 est dérivée de la classe 1 et la classe 3 est dérivée de la classe 2.
Implémentation de l'héritage multiple
Exemple 1
Cet exemple est un échantillon d'utilisation de l'héritage car plusieurs héritages contiennent un enfant avec deux parents. Ici, ici, la classe C est une classe d'enfants, tandis que la classe A et la classe B sont des classes de parents. Chaque classe comprend un constructeur qui affiche un message chaque fois que l'objet de classe est créé. L'utilisation de la bibliothèque iOStream aide à déclarer CIN, COUT FONCTIONNAIRES. Les deux classes de parents sont déclarées de quelque manière que ce soit, mais tout en déclarant la classe d'enfants, nous devons mentionner les deux classes de parents héritées de la classe d'enfants. Ici, l'ordre des deux classes doit être gardé à l'esprit. La classe déclarée d'abord doit être mentionnée en dernier.
Par exemple, dans l'exemple donné, la classe A est créée en premier dans le code source à mentionner après B, et la classe B sera mentionnée en premier.
Classe C: public B, public A
Nous allons créer un objet pour la classe enfant uniquement dans le programme principal, comme dans le processus d'héritage, l'objet de classe d'enfants accède automatiquement à la classe parent. Enregistrez maintenant le fichier avec le '.C 'Extension, compilez le code via un compilateur G ++. '-o' est utilisé pour enregistrer la sortie du fichier.
$ g ++ -o multi-multi.c
$ ./multi
Sur une exécution réussie, la réponse sera affichée. Vous pouvez voir que le constructeur de la classe B sera exécuté d'abord simplement à cause de l'ordre requis, bien qu'il ait été déclaré plus tard, puis le constructeur de la classe A est exécuté, et à la fin, la classe d'enfants elle-même est exécutée.
Exemple 2
Voici un exemple de multiples héritages où une «poupée» de classe d'enfants contient deux parents, un jouet et un plushtoy. Ces classes sont déclarées de la même manière que nous l'avons fait dans le dernier exemple. Chaque constructeur est créé pour les deux classes parentales. La troisième classe, la classe enfant, n'est déclarée que, mais son constructeur n'est pas créé; il n'y a qu'une déclaration. Ici, la commande de la déclaration de la classe parent est modifiée, car le jouet de classe est déclaré en premier, doit être mentionné plus tard, mais au moment de déclarer la classe infantile, il est mentionné en premier; De même, Class Plushtoy est déclaré plus tard mentionné également après le jouet de classe.
Lors de la création de l'objet, les constructeurs de la classe parent seront exécutés en fonction de l'ordre mentionné lors de la déclaration de la classe enfant.
Exécutez maintenant le code; Vous verrez que le constructeur du jouet parent est d'abord exécuté, puis le constructeur de la classe «Plushtoy» est exécuté.
Exemple 3
Un problème de diamant se produit dans la situation où deux parents (superclasse) ont une classe de base commune. Par exemple, l'enfant C a deux parents, A et B, et ceux-ci appartiennent tous les deux à une seule classe de base D. Ainsi, la classe C child C contiendra indirectement deux copies de la classe D, ce qui mène à l'ambiguïté. Ce problème est expliqué via le code source C ++.
Une personne de classe est créée en tant que classe de base et a un constructeur pour afficher un message. Une autre faculté de classe est créée qui est un enfant de la «personne» de la classe de base et a un constructeur dans la partie publique de la classe. Comme les professeurs, un étudiant de classe est également créé qui hérite de la personne de classe de base parentale.
Les professeurs et les étudiants deviennent des parents superclasse dans les deux classes lorsqu'une classe TA en dérive. Cette classe d'enfants TA est déclarée en ayant les noms des deux classes parentales.
Classe TA: Faculté publique: étudiant public
Cela forme un diamant; Deux classes héritent d'une seule classe, tandis qu'une seule classe est héritée de ces deux classes. Si indirectement, la classe d'enfants contiendra des données de la classe de base de ses parents.
La création d'objets iniège tous les constructeurs des classes décrites ci-dessus.
Lorsque le programme sera exécuté, vous verrez que le constructeur de classe de professeurs sera exécuté en premier, car l'ordre était qu'il avait été mentionné en premier tout en déclarant une classe d'enfants. Ainsi, la classe du corps professoral affichera d'abord le message de classe de personne puis son message; De même, la classe étudiante imprimera à nouveau la classe de personne d'abord, puis son message. Et à la fin, le message de classe infantile s'affiche.
Si un processus ou une opération est déclaré dans la classe de base, il sera copié deux fois. Cela provoquera une ambiguïté.
Pour supprimer ce problème, il y a une solution. Le mot-clé «virtuel» est utilisé dans cet aspect. L'utilisation du mot-clé virtuel avec la classe parentale, les professeurs et l'élève éviteront la création de deux copies d'une classe de base. Ceci est appliqué à un exemple affiché ci-dessous.
Le code restant est le même. Cela fonctionnera pour que le constructeur de classe de base (personne) soit appelé par défaut lorsque l'objet est créé. Cela éliminera la duplication du même message ou de toute opération.
Maintenant, nous allons exécuter le code pour voir les résultats. Le constructeur de classe de base n'est exécuté qu'une seule fois.
Conclusion
«L'héritage multiple C ++» contient l'explication de base de l'héritage et l'inclut dans le code. Certains exemples élémentaires sont implémentés en C ++ pour expliquer le fonctionnement de plusieurs héritages. Ce guide est livré avec des problèmes d'héritage majeurs comme le problème du diamant. Il est élaboré en détail, et la solution à elle est également mise en évidence. Espérons que cet effort sera une source de connaissances complètes pour les nouveaux utilisateurs.