Problème de diamant C ++

Un problème de diamant est un problème qui se produit dans les langages de programmation, en particulier dans C ++, lorsque vous utilisez plusieurs héritages. Les héritages multiples en C ++ sont couramment utilisés comme outil lorsque le code est très long. Donc, pour gérer le code source, nous utilisons des classes pour gérer le programme. Cependant, les multiples héritages causent un problème s'il n'est pas utilisé correctement. Ces problèmes contiennent principalement le problème du diamant. Ce tutoriel vise à mettre en évidence les principaux facteurs du problème du diamant, comment il se produit à partir des multiples héritages, et toutes les solutions nécessaires pour le résoudre.

Pour exécuter les programmes concernant «l'héritage du diamant C ++» dans le système d'exploitation Linux, vous devez faire installer un système Ubuntu et fonctionner sur la machine virtuelle. Deux outils sont utilisés. L'un est n'importe quel outil d'édition, et en tant que tel, nous utiliserons «l'éditeur de texte» par défaut de Linux. Vous pouvez utiliser d'autres outils d'édition préférés. Le second est le terminal Ubuntu. Sur lequel, vous exécuterez le programme et pouvez voir la sortie affichée.

Premièrement, nous discuterons de plusieurs héritages dans l'article, car le «problème de diamant» se produit dans le cas d'avoir l'héritage dans le code source.

Plusieurs héritages en c++

Lorsque nous parlons de l'utilisation des classes hiérarchiquement dans le programme, nous connaissons toujours la POO (programmation orientée objet). Parce que cet héritage est une caractéristique importante de l'objet, où une sous-classe est capable de hériter d'une ou plusieurs superclasses. De cette façon, une classe d'enfants a deux parents ou plus.

Par exemple, si une mère et un père ont un enfant dans un scénario réel, l'enfant héritera tout des parents. Cet enfant est donc connu pour être une classe dérivée avec la mère et le père en tant que parents. Revenons vers les multiples héritages. Nous utiliserons des «constructeurs» dans le cadre de notre discussion actuelle. Les constructeurs d'une classe héritée (classe d'enfants) dans plusieurs héritages s'exécutent en suivant leur ordre hérité. Tandis que pour les destructeurs, l'ordre est l'inverse de l'héritage. Maintenant, nous citerons un exemple simple pour démontrer la fonctionnalité de l'héritage en C++.

Exemple de multiples héritages

Considérez un exemple dans lequel il y a deux classes, la classe A et la classe B, en tant que classe parent, et ces deux classes ont une classe d'enfants nommée classe C. Cette classe est une classe dérivée de ses deux parents. Nous utiliserons un constructeur dans la partie publique de chaque classe.

La première étape du code consiste à utiliser une bibliothèque pour permettre le streaming d'entrée: streaming:

Ensuite, nous devons déclarer la classe A, ayant les constructeurs avec le nom de la classe. Comme vous le savez, les constructeurs sont déclarés avec le nom de cette classe, et ceux-ci sont appelés chaque fois que l'objet est créé. Dans le constructeur, un message simple a été affiché qui montre quel constructeur de classe est exécuté. Maintenant, nous définissons la classe B avec la même approche. Après les deux classes parentales, la classe infantile est mentionnée.

Une chose qui devrait être notée ici est l'ordre des classes de parents dont l'enfant hérite car cet ordre aura une importance au moment de l'exécution du constructeur et un message affichant.

Maintenant, dans la classe principale, nous allons créer un objet de la classe enfant. Comme il a plusieurs héritages, il n'est pas nécessaire de créer l'objet pour la classe parent. Ils sont automatiquement exécutés à cause de l'objet de classe enfant:

Int main ()
C c;
Retour 0;

Après avoir écrit le code précédent dans l'éditeur de texte, enregistrez ce fichier avec l'extension de '.C '. Nous exécuterons le fichier dans le terminal Ubuntu. À des fins d'exécution, un compilateur est requis. En C ++, nous utilisons un compilateur G ++. Sinon, vous devez d'abord l'installer:

$ G ++ -o m1 m1.c
$ ./ M1

Utilisez G ++ avec le nom du fichier ayant le code source et celui dans lequel vous souhaitez afficher la sortie. Remarque, -o, est utilisé pour enregistrer la sortie. Comme la classe B est héritée au-dessus de la classe A, donc son constructeur est exécuté en premier, vous pouvez voir la sortie de l'image précédente.

Comme le concept de succession est clair maintenant, nous discuterons du «problème de diamant» ici.

Problème de diamant

Un problème de diamant est un cas uniquement dans plusieurs héritages qui se produisent lorsqu'une classe d'enfants a les valeurs héritées des deux parents. Dans lequel ces classes de parents sont héritées d'une classe de grands-parents commune.

Par exemple, considérons un exemple dans lequel nous avons une classe d'enfants héritée des classes de mère et de père. Ces classes héritent d'une troisième classe nommée «personne»:

Enfant> Mère> Personne
> Père> Personne

Ainsi, selon le scénario donné, la classe d'enfants hérite de la classe «personne» deux fois dans le programme. Une fois, c'est de la mère, et encore une fois, la deuxième fois est du père. Cela crée une confusion pour le compilateur pour exécuter le constructeur d'abord. Cette situation provoque un graphique d'héritage en forme de diamant. Par conséquent, il est connu comme «le problème du diamant».

L'approche de code est presque la même. Déclarez la classe de base, puis deux classes en enfant hérité (mère, père) de la classe de base. Chaque classe est suivie par le constructeur avec une variable pour y stocker une valeur:

Maintenant, introduisant la classe infantile:

# Enfant de classe: père public, mère publique

La classe infantile héritera des deux classes parentales. La fonction principale utilisera l'objet de l'enfant et une valeur dans le paramètre de l'appel constructeur:

Après avoir enregistré le code, il est temps d'utiliser le compilateur pour l'exécution et de voir le résultat:

Maintenant, vous pouvez observer que la classe de base est appelée deux fois. C'est un problème de diamant. Après avoir décrit le problème, nous trouverons maintenant une solution possible.

Solution de problème de diamant

La solution dépend de l'utilisation du mot-clé «virtuel». Les classes biparentales avec une classe de base commune hériteront désormais de la classe de base pratiquement pour minimiser l'occurrence de copies de la classe de base dans la classe enfant. Maintenant, nous allons modifier le code en utilisant ce mot-clé:

Chaque fois que la classe parent hérite de la classe des grands-parents, «virtuel» est utilisé mais uniquement avec les parents, pas dans le cas d'un enfant. C'est «l'héritage virtuel». Il limite le passage de plus d'une seule instance de la classe de base à passer.

# Père de classe: Personne publique virtuelle

Maintenant, nous allons exécuter le code. Les valeurs résultantes montrent que l'ambiguïté est supprimée en utilisant ce concept:

Pour éviter que la répétition du constructeur de base soit appelée, le constructeur d'une classe de base virtuelle n'est pas atteint à travers la classe qui l'a héritée. Cependant, ce constructeur est appelé à partir du constructeur de classe en béton. Dans l'exemple actuel, la classe d'enfants appelle directement le constructeur de classe «personne».

Conclusion

«C ++ Diamond Problem» est un article écrit pour supprimer l'ambiguïté de la répétition de la classe de base en plusieurs héritages. Le concept d'héritage s'explique brièvement avec des exemples. De même, la cause et la solution pour le problème du diamant sont également élaborées en détail. Nous espérons que ce tutoriel pourra vous fournir des conseils dans le domaine des programmes C ++.