Polymorphisme C ++

Dans ce tutoriel, nous allons apprendre le polymorphisme en C ++ à l'aide d'exemples.

Le polymorphisme est un concept important de la programmation orientée objet. Cela signifie simplement plus d'un formulaire. Autrement dit, la même entité (fonction ou opérateur) se comporte différemment dans différents scénarios. Par exemple,

L' +opérateur en C ++ est utilisé pour exécuter deux fonctions spécifiques. Lorsqu'il est utilisé avec des nombres (entiers et nombres à virgule flottante), il effectue une addition.

 int a = 5; int b = 6; int sum = a + b; // sum = 11

Et lorsque nous utilisons l' +opérateur avec des chaînes, il effectue une concaténation de chaînes. Par exemple,

 string firstName = "abc "; string lastName = "xyz"; // name = "abc xyz" string name = firstName + lastName;

Nous pouvons implémenter le polymorphisme en C ++ en utilisant les méthodes suivantes:

  1. Surcharge de fonction
  2. Surcharge de l'opérateur
  3. Remplacement de fonction
  4. Fonctions virtuelles

Surcharge de fonction C ++

En C ++, nous pouvons utiliser deux fonctions ayant le même nom si elles ont des paramètres différents (soit des types, soit un nombre d'arguments).

Et, selon le nombre / le type d'arguments, différentes fonctions sont appelées. Par exemple,

 // C++ program to overload sum() function #include using namespace std; // Function with 2 int parameters int sum(int num1, int num2) ( return num1 + num2; ) // Function with 2 double parameters double sum(double num1, double num2) ( return num1 + num2; ) // Function with 3 int parameters int sum(int num1, int num2, int num3) ( return num1 + num2 + num3; ) int main() ( // Call function with 2 int parameters cout << "Sum 1 = " << sum(5, 6) << endl; // Call function with 2 double parameters cout << "Sum 2 = " << sum(5.5, 6.6) << endl; // Call function with 3 int parameters cout << "Sum 3 = " << sum(5, 6, 7) << endl; return 0; )

Production

 Somme 1 = 11 Somme 2 = 12,1 Somme 3 = 18

Ici, nous avons créé 3 sum()fonctions différentes avec des paramètres différents (nombre / type de paramètres). Et, en fonction des arguments passés lors d'un appel de fonction, un particulier sum()est appelé.

C'est un polymorphisme à la compilation car le compilateur sait quelle fonction exécuter avant que le programme ne soit compilé.

Pour en savoir plus, consultez notre didacticiel sur la surcharge de fonctions C ++.

Surcharge des opérateurs C ++

En C ++, nous pouvons surcharger un opérateur tant que nous opérons sur des types définis par l'utilisateur comme des objets ou des structures.

Nous ne pouvons pas utiliser la surcharge d' opérateur pour les types de base tels que int, double, etc.

La surcharge d'opérateur est essentiellement une surcharge de fonction, où différentes fonctions d'opérateur ont le même symbole mais des opérandes différents.

Et, selon les opérandes, différentes fonctions d'opérateur sont exécutées. Par exemple,

 // C++ program to overload ++ when used as prefix #include using namespace std; class Count ( private: int value; public: // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix void operator ++() ( value = value + 1; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1; // Call the "void operator ++()" function ++count1; count1.display(); return 0; )

Production

 Nombre: 6

Ici, nous avons surchargé l' ++opérateur, qui opère sur des objets de Countclasse (object count1 dans ce cas).

Nous avons utilisé cet opérateur surchargé pour incrémenter directement la variable de valeur de l'objet count1 de 1.

C'est aussi un polymorphisme à la compilation .

Pour en savoir plus, visitez notre didacticiel sur la surcharge d'opérateurs C ++.

Remplacement de fonction C ++

Dans l'héritage C ++, nous pouvons avoir la même fonction dans la classe de base ainsi que ses classes dérivées.

Lorsque nous appelons la fonction à l'aide d'un objet de la classe dérivée, la fonction de la classe dérivée est exécutée à la place de celle de la classe de base.

Ainsi, différentes fonctions sont exécutées en fonction de l'objet appelant la fonction.

C'est ce qu'on appelle le remplacement de fonction en C ++. Par exemple,

 // C++ program to demonstrate function overriding #include using namespace std; class Base ( public: virtual void print() ( cout << "Base Function" << endl; ) ); class Derived : public Base ( public: void print() ( cout << "Derived Function" << endl; ) ); int main() ( Derived derived1; // Call print() function of Derived class derived1.print(); return 0; )

Production

 Fonction dérivée

Ici, nous avons utilisé une print()fonction dans la Baseclasse et la même fonction dans la Derivedclasse

Lorsque nous appelons en print()utilisant l' Derivedobjet dérivé1, il remplace la print()fonction de Baseen exécutant la print()fonction de la Derivedclasse.

C'est un polymorphisme à l'exécution car l'appel de fonction n'est pas résolu par le compilateur, mais il est résolu à la place à l'exécution.

Pour en savoir plus, consultez notre didacticiel sur le remplacement des fonctions C ++.

Fonctions virtuelles C ++

En C ++, il se peut que nous ne puissions pas remplacer les fonctions si nous utilisons un pointeur de la classe de base pour pointer vers un objet de la classe dérivée.

L'utilisation de fonctions virtuelles dans la classe de base garantit que la fonction peut être remplacée dans ces cas.

Ainsi, les fonctions virtuelles relèvent en fait du remplacement de fonction . Par exemple,

 // C++ program to demonstrate the use of virtual functions #include using namespace std; class Base ( public: virtual void print() ( cout << "Base Function" << endl; ) ); class Derived : public Base ( public: void print() ( cout << "Derived Function"

Output

 Derived Function

Here, we have used a virtual function print() in the Base class to ensure that it is overridden by the function in the Derived class.

Virtual functions are runtime polymorphism.

To learn more, visit our C++ Virtual Functions tutorial.

Why Polymorphism?

Polymorphism allows us to create consistent code. For example,

Suppose we need to calculate the area of a circle and a square. To do so, we can create a Shape class and derive two classes Circle and Square from it.

In this case, it makes sense to create a function having the same name calculateArea() in both the derived classes rather than creating functions with different names, thus making our code more consistent.

Articles intéressants...