Types de polymorphisme - temporaire, contenu, paramétré et coercitif

Ici, nous verrons différents types de polymorphisme. Les types de -

• Ad-Hoc
• contiennent
• paramétrage
• force

Le polymorphisme Ad-Hoc est appelé surcharge. Cela permet aux fonctions portant le même nom d'agir différemment pour différents types. Les fonctions et les opérateurs peuvent être surchargés. Certains langages ne prennent pas en charge la surcharge d'opérateurs, mais la surcharge de fonctions est courante.

Exemple

#include<iostream>
using namespace std;
int add(int a, int b) {
   return a + b;
}
string add(string a, string b) {
   return a + b; //concatenate
}
int main() {
   cout << "Addition of numbers: " << add(2, 7) << endl;
   cout << "Addition of Strings: " << add("hello", "World") << endl;
}

Sortie

Addition of numbers: 9
Addition of Strings: helloWorld

Contenant un polymorphisme est appelé sous-typage. Cela permet d'utiliser des pointeurs de classe de base et des références pour pointer vers des classes dérivées. Il s’agit du polymorphisme d’exécution. Nous ne connaissons pas le type d'objet réel avant l'exécution. Nous avons besoin de fonctions virtuelles en C++ pour réaliser ce polymorphisme d'inclusion.

Exemple

#include<iostream>
using namespace std;
class Base {
   public:
      virtual void print() {
         cout << "This is base class." << endl;
      }
};
class Derived : public Base {
   public:
      void print() {
         cout << "This is derived class." << endl;
      }
};
int main() {
   Base *ob1;
   Base base_obj;
   Derived derived_obj;
   ob1 = &base_obj; //object of base class
   ob1->print();
   ob1 = &derived_obj; //same pointer to point derived object
   ob1->print();
}

Sortie

This is base class.
This is derived class.

Le polymorphisme forcé est appelé un casting. Ce type de polymorphisme se produit lorsqu'un objet ou une primitive est converti en un autre type. Il existe deux types de casting. Les conversions implicites sont effectuées à l'aide du compilateur lui-même, les conversions explicites sont effectuées à l'aide de const_cast, Dynamic_cast, etc.

Exemple

#include<iostream>
using namespace std;
class Integer {
   int val;
   public:
      Integer(int x) : val(x) {
   }
   operator int() const {
      return val;
   }
};
void display(int x) {
   cout << "Value is: " << x << endl;
}
int main() {
   Integer x = 50;
   display(100);
   display(x);
}

Sortie

Value is: 100
Value is: 50

Le polymorphisme paramétrique est appelé liaison précoce. Ce type de polymorphisme permet d'utiliser le même code pour différents types. Nous pouvons l'obtenir en utilisant des modèles.

Exemple

#include<iostream>
using namespace std;
template <class T>
T maximum(T a, T b) {
   if(a > b) {
      return a;
   } else {
      return b;
   }
}
int main() {
   cout << "Max of (156, 78): " << maximum(156, 78) << endl;
   cout << "Max of (A, X): " << maximum(&#39;A&#39;, &#39;X&#39;) << endl;
}

Sortie

Max of (156, 78): 156
Max of (A, X): X

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!