Cependant, un destructeur virtuel pourrait exister. Ici, nous allons montrer ce qui se passe lorsque nous créons un constructeur virtuel en C++ ainsi que le fonctionnement du destructeur virtuel au lieu du constructeur virtuel.
Exemple 1:
Créons le constructeur virtuel et commençons notre code en plaçant le fichier d'en-tête « iostream ». Ce fichier d'en-tête est destiné aux fonctions qui y sont déclarées comme « cin » et « cout ». Après cela, nous ajoutons l'espace de noms « std », nous ne pouvons donc pas ajouter ce « std » avec chaque fonction de notre code. Après cela, nous créons une classe qui est la classe de base de notre code avec le nom « my_base », puis ajoutons « public » pour créer le constructeur virtuel.
Le constructeur virtuel est créé ici en plaçant le mot-clé « virtuel ». À l'intérieur de ce constructeur virtuel, nous plaçons une instruction « cout ». En dessous, nous créons une fonction nommée « show » dans laquelle nous utilisons à nouveau le « cout ». Après cela, nous créons une classe dérivée de cette classe de base avec le nom « my_derived » puis établissons le constructeur « my_derived() » dans le champ « public ». Nous insérons une instruction « cout » dans ce constructeur « my_derived() ». En dessous, nous construisons une fonction appelée « show » où nous utilisons à nouveau le « cout ».
Maintenant, après avoir invoqué le « main() », nous créons un pointeur de la classe de base avec le nom « my_ptr » et créons également l'objet de la classe dérivée qui est « Obj_d ». Après cela, nous attribuons l'adresse du « Obj_d » au « my_ptr ». Ensuite, nous appelons la fonction « show() » via « my_ptr ».
Codage 1 :
#include
en utilisant espace de noms norme ;
classe ma_base
{
publique :
virtuel ma_base ( )
{
cout << 'Voici ma classe de base' << fin ;
}
vide montrer ( )
{
cout << 'la fonction show de la classe de base' << fin ;
}
} ;
classe mon_derived : publique ma_base
{
publique :
mon_derived ( )
{
cout << 'Voici ma classe dérivée' << fin ;
}
vide montrer ( )
{
cout << 'la fonction show de la classe dérivée' < montrer ( ) ;
}
Sortir:
Ici, il affiche un message d'erreur indiquant que le constructeur ne peut pas être déclaré virtuel dans la programmation C++. Ainsi, nous pouvons voir que C++ ne nous permet pas de générer le constructeur virtuel mais nous pouvons créer le destructeur virtuel.
Exemple 2 :
Résolvons le problème précédent et créons le destructeur virtuel dans ce code. Après avoir déclaré la classe « new_base », on place le constructeur « public » dans lequel on crée le destructeur virtuel en ajoutant « virtual ~ » avec la « new_base ». Nous insérons une instruction « cout » dans ce destructeur virtuel. En dessous, nous construisons une fonction appelée « show » qui utilise le « cout ». Ensuite, nous créons une classe dérivée qui est « new_derived » de cette classe de base « new_base » et construisons le destructeur « new_derived() » dans le champ « public ». Ce destructeur « new_derived() » a désormais une instruction « cout » ajoutée.
En dessous, nous créons une fonction appelée « show » qui utilise à nouveau l'instruction « cout ». Après avoir appelé la fonction « main() », nous produisons maintenant un objet de la classe dérivée « obj_d » ainsi qu'un pointeur de la classe de base nommé « ptr1 ». Suite à cela, nous donnons l'adresse « obj_d » au « ptr1 ». Ensuite, la méthode « show() » est invoquée en utilisant « ptr1 ».
Code 2 :
#includeen utilisant espace de noms norme ;
classe nouvelle_base
{
publique :
virtuel ~nouvelle_base ( )
{
cout << 'Le destructeur de classe de base est là' << fin ;
}
vide montrer ( )
{
cout << 'La fonction show de la classe de base' << fin ;
}
} ;
classe nouveau_derived : publique nouvelle_base
{
publique :
~new_derived ( )
{
cout << 'Le destructeur de classe dérivée est ici' << fin ;
}
vide montrer ( )
{
cout << 'La fonction show de la classe de base' < montrer ( ) ;
}
Sortir:
Ce programme utilise un objet pointeur de « new_base » qui pointe vers la classe dérivée « obj_d ». Ainsi, il appelle en premier la méthode « show() » de la classe « new_base ». Ensuite, il appelle la méthode « ~new_derived() » de la classe « new_derived » et affiche le « ~new_base » de la classe de base.
Exemple 3 :
Voici un autre code pour générer le constructeur « virtuel ». Après avoir inclus les espaces de noms « iostream » et « std », nous générons une classe « B ». En dessous, nous créons le constructeur « public » qui est « B() » puis générons le « cout ». Les fonctions constructeur et destructeur sont définies en utilisant un spécificateur d'accès « public » auquel n'importe quel objet de la classe peut appeler.
Maintenant, nous créons également le destructeur « ~B() » de cette classe de base dans lequel nous utilisons à nouveau le « cout ». Ensuite, nous créons la classe « D » qui est la classe dérivée de la classe de base « B » et plaçons ici le « public ». A l'intérieur de ce « public », nous créons le constructeur ainsi que le destructeur de la classe dérivée avec les noms « D() » et « ~D », respectivement. Les deux contiennent le « cout » à l’intérieur. Maintenant, nous avons la fonction « main() ». Après avoir appelé cette fonction, nous générons l’objet pointeur de la classe de base.
Ensuite, nous utilisons le mot-clé « delete » et plaçons « base_ptr » ici. Dans ce cas, l’espace du destructeur est supprimé en appelant l’objet pointeur de la classe de base.
Code 3 :
#includeen utilisant espace de noms norme ;
classe B
{
publique :
B ( )
{
cout << 'Constructeur de la classe Base' << fin ;
}
~B ( )
{
cout << 'Destructeur de la classe Base' << fin ;
}
} ;
classe D : publique B
{
publique :
D ( )
{
cout << 'Constructeur de la classe Dérivée' << fin ;
}
~D ( )
{
cout << 'Destructeur de la classe Dérivée' << fin ;
}
} ;
int principal ( )
{
B * base_ptr = nouveau D ;
supprimer base_ptr ;
}
Sortir:
Le résultat montre qu'il utilise un objet pointeur qui pointe vers la classe « B » dans la fonction principale. Ainsi, il appelle en premier le « constructeur() » de la classe « B ». Ensuite, il appelle le « constructeur() » de la classe « D ». L'objet pointeur détenu par les destructeurs des classes « B » et « D » est alors supprimé. Sans invoquer le destructeur de la classe « D » au sein du programme, le pointeur de classe « B » élimine uniquement le destructeur de la classe « B ». En conséquence, la mémoire du programme est corrompue.
Conclusion
Nous avons discuté du concept de « construction virtuelle » en programmation C++. Nous avons exploré le fait que nous ne pouvons pas créer le constructeur virtuel en C++, mais nous pouvons créer le destructeur virtuel dans nos codes. Ici, nous avons montré ce qui s'est passé lorsque nous avons créé le constructeur virtuel en programmation C++ et le fonctionnement du destructeur virtuel dans nos codes. Nous avons appris que le constructeur ne peut pas être virtuel, mais nous pouvons générer le destructeur virtuel dans notre classe. Nous avons montré quelques exemples et expliqué ces codes en détail dans ce guide.