Polymorphisme dans les exemples de C ++

Le polymorphisme, qui implique «diverses formes», se produit lorsque plusieurs classes sont connectées via l'hérédité. Dans divers contextes, la même chose (méthode ou opérateur) agit différemment. Nous pouvons hériter des propriétés et des fonctions d'une autre classe via l'hérédité. Le polymorphisme utilise ces techniques à diverses fins. Cela nous permet d'effectuer une activité particulière de diverses manières. Par conséquent, dans cet article, nous discuterons des exemples de polymorphisme en C ++ en utilisant quelques exemples dans Ubuntu 20.04. Nous l'avons commencé par la création et le lancement d'un nouveau fichier C ++ dans la console terminale.

Polymorphisme $ touche.CC
$ Nano Polymorphisme.CC

Exemple 01: surcharge de fonction

Lorsque leurs arguments sont uniques, vous pouvez utiliser deux fonctions principales avec le même titre en C++. Diverses méthodes sont appelées basées sur la quantité et le type de paramètres, et ce concept est connu sous le nom de surcharge de fonction. Nous avons commencé notre premier exemple avec l'espace de noms «STD» standard et l'en-tête d'entrée «iOStream». Trois fonctions «Val» définies par l'utilisateur sont définies, chacune contenant une seule instruction COUT. La première fonction contient un paramètre de type entier, le second contient le paramètre à double type, et le dernier contient deux paramètres de type double. Les deux premières fonctions «Val» obtiennent simplement la valeur de la méthode principale () et l'afficher sur le shell via l'instruction COUT. Le troisième obtient deux valeurs de type double de la main () et affiche la somme des deux valeurs sur la coque à l'aide de la clause COUT. La fonction principale () est simplement d'appeler trois méthodes de même nom les unes après les autres en passant différentes valeurs.

#inclure
Utilisation de Namespace Std;
int Val (int n1)
couter <<"Integer: "<< n1 <
double val (double n1)
couter <<"Double: "<< n1 <
double val (double n1, double n2)
couter << "Sum: "<< n1+n2<
int main()
Val (10);
Val (9.25);
Val (4.1, 8.23);
retour 0;

La compilation de ce code C ++ est réussie à l'aide du compilateur G ++ sur le shell.

$ G ++ Polymorphisme.CC

Après avoir exécuté le code, nous avons les valeurs affichées sur la console ci-dessous.

$ ./un.dehors

Exemple 02: surcharge de l'opérateur

La surcharge de l'opérateur est similaire à la surcharge de méthode car elle utilise le même signe mais divers opérandes pour des méthodes d'opérateur distinctes. Nous avons donc commencé cet exemple en déclarant une nouvelle classe «A» après l'espace de noms et la bibliothèque d'en-tête. La classe A contient un membre de données privé de type entier «V», et une fonction de constructeur A () utilisée pour initialiser la variable «V» avec une valeur de 5. Voici la fonction de l'opérateur pour incrémenter la valeur de «V» par 3. Comme son nom le montre, l'opérateur «+» a été surchargé ici. La fonction show () est là pour montrer la valeur incrémentée d'une variable «V.«Lors de la création d'un objet, le constructeur a () sera exécuté. L'objet a été utilisé pour appeler la fonction d'opérateur «++». L'OBJ est à nouveau utilisé pour appeler la fonction show () pour afficher la valeur incrémentée.

#inclure
Utilisation de Namespace Std;
Classe A
privé:
à la TV;
public:
A (): v (5)
void opérateur ++ ()
v = v + 3;

void show ()
couter << "Value after increment: " << v << endl;

;
int main()
Un obj;
++obj;
obj.montrer();
retour 0;

Après la compilation, nous n'avons aucune erreur. La valeur incrémentée de la variable «V» a été affichée sur notre écran de terminal lors de l'exécution de ce code.

$ G ++ Polymorphisme.CC
$ ./un.dehors

Exemple 03: fonction de fonctionnement

La classe de base et ses sous-classes descendantes peuvent avoir les mêmes méthodes de nom. Lorsque nous utilisons une instance de la sous-classe pour invoquer la méthode, la fonction de la classe étendue est exécutée plutôt que la classe parent. En conséquence, diverses fonctions s'exécuteront en fonction de l'objet invoquant la méthode. En C ++, ceci est appelé méthode dominante. Donc, nous avons initialisé trois classes dans le code. La classe A est la classe parentale des deux classes d'enfants B et C. Toutes les classes ont la même fonction de nom, «show ()», affichant ses spécifications via une instruction COUT. La méthode Main () a créé 3 objets pour 3 classes pour appeler les fonctions respectives.

#inclure
Utilisation de Namespace Std;
Classe A
public:
void show ()
couter << "Base class A… " << endl;
;
classe B: public a
public:
void show ()
couter << "Derived class B… " << endl;
;
classe C: public a
public:
void show ()
couter << "Derived class C… " << endl;
;
int main()
Un o1;
O1.montrer();
B o2;
O2.montrer();
C O3;
O3.montrer();
retour 0;

Nous avons toutes les méthodes exécutées à partir de toutes les classes lors de l'exécution de ce fichier de code.

Exemple 04: fonctions virtuelles

Si nous utilisons une référence de classe de base «pointeur» pour faire référence à un objet de classe dérivé, nous pouvons même ne pas être capables de contourner les méthodes en C++. Dans ces circonstances, l'utilisation de méthodes virtuelles dans la classe des parents garantit que la méthode peut être remplacée. Donc, nous avons créé une classe Parent A avec sa classe Child B. Les deux classes ont les fonctions du même nom, mais la fonction de classe parent contient le mot-clé «virtuel.«Dans main (), l'objet de classe B« B »a été utilisé comme référence à l'objet de pointeur de classe parent« A »« A."

#inclure
Utilisation de Namespace Std;
Classe A
public:
virtual void show ()
couter << "Base class A… " << endl;

;
classe B: public a
public:
void show ()
couter << "Derived class B… " retour 0;

Lors de l'exécution de ce code, la méthode de classe dérivée a été exécutée à l'aide du mot-clé virtuel dans la fonction de même nom définie par l'utilisateur de la classe parent.

$ G ++ Polymorphisme.CC
$ ./un.outg

Conclusion:

Il s'agissait d'utiliser le polymorphisme en C ++ en utilisant certains de ses concepts de base. Pour le rendre fluide, nous avons couvert la surcharge des fonctions, la fonction de fonctionnement de la fonction, la surcharge de l'opérateur et le concept de fonction virtuelle. Nous espérons les meilleurs commentaires pour ce travail.