Le mot polymorphisme signifie avoir plusieurs formes. En termes simples, nous pouvons définir le polymorphisme comme la capacité d’un message à s’afficher sous plusieurs formes. Un exemple concret de polymorphisme est celui d’une personne qui peut en même temps avoir des caractéristiques différentes. Un homme est à la fois père, mari et employé. Ainsi, la même personne présente un comportement différent selon les situations. C'est ce qu'on appelle le polymorphisme. Le polymorphisme est considéré comme l'une des caractéristiques importantes de la programmation orientée objet.
Types de polymorphisme
- Polymorphisme au moment de la compilation
- Polymorphisme d'exécution
Types de polymorphisme
1. Polymorphisme au moment de la compilation
Ce type de polymorphisme est obtenu par surcharge de fonctions ou d'opérateurs.
A. Surcharge de fonctions
Lorsqu’il existe plusieurs fonctions portant le même nom mais des paramètres différents, alors les fonctions sont dites surchargé, c'est pourquoi c'est ce qu'on appelle la surcharge de fonctions. Les fonctions peuvent être surchargées par changer le nombre d'arguments ou et changer le type d'arguments . En termes simples, il s'agit d'une fonctionnalité de la programmation orientée objet fournissant de nombreuses fonctions portant le même nom mais des paramètres distincts lorsque de nombreuses tâches sont répertoriées sous un seul nom de fonction. Il existe certaines règles de surcharge de fonctions qui doivent être suivies lors de la surcharge d'une fonction.
Vous trouverez ci-dessous le programme C++ permettant d'afficher la surcharge de fonctions ou le polymorphisme à la compilation :
C++
// C++ program to demonstrate> // function overloading or> // Compile-time Polymorphism> #include> using> namespace> std;> class> Geeks {> public>:> >// Function with 1 int parameter> >void> func(>int> x)> >{> >cout <<>'value of x is '> << x << endl;> >}> >// Function with same name but> >// 1 double parameter> >void> func(>double> x)> >{> >cout <<>'value of x is '> << x << endl;> >}> >// Function with same name and> >// 2 int parameters> >void> func(>int> x,>int> y)> >{> >cout <<>'value of x and y is '> << x <<>', '> << y> ><< endl;> >}> };> // Driver code> int> main()> {> >Geeks obj1;> >// Function being called depends> >// on the parameters passed> >// func() is called with int value> >obj1.func(7);> >// func() is called with double value> >obj1.func(9.132);> >// func() is called with 2 int values> >obj1.func(85, 64);> >return> 0;> }> |
>
pyspark sql
>Sortir
value of x is 7 value of x is 9.132 value of x and y is 85, 64>
Explication: Dans l'exemple ci-dessus, une seule fonction nommée function fonction() agit différemment dans trois situations différentes, ce qui est une propriété du polymorphisme. Pour en savoir plus, vous pouvez vous référer à l’article – Surcharge de fonctions en C++ .
B. Surcharge des opérateurs
C++ a la capacité de fournir aux opérateurs une signification particulière pour un type de données, cette capacité est connue sous le nom de surcharge d'opérateurs. Par exemple, nous pouvons utiliser l’opérateur d’addition (+) pour la classe de chaînes pour concaténer deux chaînes. On sait que la tâche de cet opérateur est d'ajouter deux opérandes. Ainsi, un seul opérateur «+», lorsqu'il est placé entre des opérandes entiers, les ajoute et lorsqu'il est placé entre des opérandes de chaîne, les concatène.
Vous trouverez ci-dessous le programme C++ pour démontrer la surcharge des opérateurs :
RPC
valeur de chaîne de
// C++ program to demonstrate> // Operator Overloading or> // Compile-Time Polymorphism> #include> using> namespace> std;> class> Complex {> private>:> >int> real, imag;> public>:> >Complex(>int> r = 0,>int> i = 0)> >{> >real = r;> >imag = i;> >}> >// This is automatically called> >// when '+' is used with between> >// two Complex objects> >Complex operator+(Complex>const>& obj)> >{> >Complex res;> >res.real = real + obj.real;> >res.imag = imag + obj.imag;> >return> res;> >}> >void> print() { cout << real <<>' + i'> << imag << endl; }> };> // Driver code> int> main()> {> >Complex c1(10, 5), c2(2, 4);> >// An example call to 'operator+'> >Complex c3 = c1 + c2;> >c3.print();> }> |
>
>Sortir
12 + i9>
Explication: Dans l’exemple ci-dessus, l’opérateur « + » est surchargé. Habituellement, cet opérateur est utilisé pour additionner deux nombres (entiers ou nombres à virgule flottante), mais ici l'opérateur est amené à effectuer l'addition de deux nombres imaginaires ou complexes. Pour en savoir plus sur celui-ci, référez-vous à l’article – Surcharge de l'opérateur .
2. Polymorphisme d'exécution
Ce type de polymorphisme est obtenu par Fonction prioritaire . La liaison tardive et le polymorphisme dynamique sont d'autres noms pour le polymorphisme d'exécution. L'appel de fonction est résolu au moment de l'exécution dans polymorphisme d'exécution . En revanche, avec le polymorphisme au moment de la compilation, le compilateur détermine quel appel de fonction se lier à l'objet après l'avoir déduit au moment de l'exécution.
A. Fonction prioritaire
Fonction prioritaire se produit lorsqu'une classe dérivée a une définition pour l'une des fonctions membres de la classe de base. Cette fonction de base est dite remplacée.
Fonction prioritaire Explication
Polymorphisme d'exécution avec les membres de données
Le polymorphisme d'exécution ne peut pas être obtenu par les données membres en C++. Voyons un exemple où nous accédons au champ par variable de référence de la classe parent qui fait référence à l'instance de la classe dérivée.
python, tri des tuples
C++
// C++ program for function overriding with data members> #include> using> namespace> std;> // base class declaration.> class> Animal {> public>:> >string color =>'Black'>;> };> // inheriting Animal class.> class> Dog :>public> Animal {> public>:> >string color =>'Grey'>;> };> // Driver code> int> main(>void>)> {> >Animal d = Dog();>// accessing the field by reference> >// variable which refers to derived> >cout << d.color;> }> |
>
>Sortir
algorithme de Bellford
Black>
Nous pouvons voir que la référence à la classe parent fera toujours référence aux données membres de la classe parent.
B. Fonction virtuelle
UN fonction virtuelle est une fonction membre déclarée dans la classe de base à l'aide du mot-clé virtual et redéfinie (substituée) dans la classe dérivée.
Quelques points clés sur les fonctions virtuelles :
- Les fonctions virtuelles sont de nature dynamique.
- Ils sont définis en insérant le mot clé virtuel à l'intérieur d'une classe de base et sont toujours déclarés avec une classe de base et remplacés dans une classe enfant
- Une fonction virtuelle est appelée pendant le Runtime
Vous trouverez ci-dessous le programme C++ pour démontrer la fonction virtuelle :
C++
// C++ Program to demonstrate> // the Virtual Function> #include> using> namespace> std;> // Declaring a Base class> class> GFG_Base {> public>:> >// virtual function> >virtual> void> display()> >{> >cout <<>'Called virtual Base Class function'> ><<>'
'>;> >}> >void> print()> >{> >cout <<>'Called GFG_Base print function'> ><<>'
'>;> >}> };> // Declaring a Child Class> class> GFG_Child :>public> GFG_Base {> public>:> >void> display()> >{> >cout <<>'Called GFG_Child Display Function'> ><<>'
'>;> >}> >void> print()> >{> >cout <<>'Called GFG_Child print Function'> ><<>'
'>;> >}> };> // Driver code> int> main()> {> >// Create a reference of class GFG_Base> >GFG_Base* base;> >GFG_Child child;> >base = &child;> >// This will call the virtual function> >base->GFG_Base::display();> >// this will call the non-virtual function> >base->imprimer();> }> |
>
>Sortir
Called virtual Base Class function Called GFG_Base print function>
Exemple 2 :
C++
entier pour doubler
// C++ program for virtual function overriding> #include> using> namespace> std;> class> base {> public>:> >virtual> void> print()> >{> >cout <<>'print base class'> << endl;> >}> >void> show() { cout <<>'show base class'> << endl; }> };> class> derived :>public> base {> public>:> >// print () is already virtual function in> >// derived class, we could also declared as> >// virtual void print () explicitly> >void> print() { cout <<>'print derived class'> << endl; }> >void> show() { cout <<>'show derived class'> << endl; }> };> // Driver code> int> main()> {> >base* bptr;> >derived d;> >bptr = &d;> >// Virtual function, binded at> >// runtime (Runtime polymorphism)> >bptr->imprimer();> >// Non-virtual function, binded> >// at compile time> >bptr->show();> >return> 0;> }> |
>
>Sortir
print derived class show base class>