Polimorfism C ++

În acest tutorial, vom învăța despre polimorfism în C ++ cu ajutorul unor exemple.

Polimorfismul este un concept important de programare orientată pe obiecte. Înseamnă pur și simplu mai multe forme. Adică, aceeași entitate (funcție sau operator) se comportă diferit în scenarii diferite. De exemplu,

+Operatorul în C ++ este folosit pentru a realiza două funcții specifice. Când este utilizat cu numere (numere întregi și cu virgulă mobilă), se efectuează adunarea.

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

Și când folosim +operatorul cu șiruri, acesta efectuează concatenarea șirurilor. De exemplu,

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

Putem implementa polimorfismul în C ++ folosind următoarele moduri:

  1. Supraîncărcarea funcției
  2. Suprasolicitarea operatorului
  3. Anularea funcției
  4. Funcții virtuale

Supraîncărcarea funcției C ++

În C ++, putem folosi două funcții cu același nume dacă au parametri diferiți (fie tipuri, fie număr de argumente).

Și, în funcție de numărul / tipul de argumente, sunt apelate diferite funcții. De exemplu,

 // 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; )

Ieșire

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

Aici, am creat 3 sum()funcții diferite cu parametri diferiți (număr / tip de parametri). Și, pe baza argumentelor transmise în timpul unui apel de funcție, sum()se numește un anumit .

Este un polimorfism de compilare, deoarece compilatorul știe ce funcție trebuie executată înainte de compilarea programului.

Pentru a afla mai multe despre acestea, vizitați tutorialul nostru de supraîncărcare a funcției C ++.

Supraîncărcarea operatorului C ++

În C ++, putem supraîncărca un operator atâta timp cât operăm pe tipuri definite de utilizator, cum ar fi obiecte sau structuri.

Nu putem folosi supraîncărcarea operatorului pentru tipuri de bază , cum ar fi int, doubleetc.

Supraîncărcarea operatorului este practic supraîncărcarea funcției, în care funcțiile operatorului diferit au același simbol, dar operanzi diferiți.

Și, în funcție de operanzi, sunt executate diferite funcții de operator. De exemplu,

 // 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; )

Ieșire

 Număr: 6

Aici, am supraîncărcat ++operatorul, care operează pe obiecte de Countclasă (număr de obiecte1 în acest caz).

Am folosit acest operator suprasolicitat pentru a crește direct variabila de valoare a obiectului count1 cu 1.

Acesta este, de asemenea, un polimorfism de compilare .

Pentru a afla mai multe, vizitați tutorialul nostru de supraîncărcare a operatorului C ++.

Anularea funcției C ++

În moștenirea C ++, putem avea aceeași funcție în clasa de bază, precum și clasele derivate ale acesteia.

Când apelăm funcția folosind un obiect al clasei derivate, funcția clasei derivate este executată în locul celei din clasa de bază.

Deci, diferite funcții sunt executate în funcție de obiectul care apelează funcția.

Acest lucru este cunoscut sub numele de funcție suprascriere în C ++. De exemplu,

 // 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; )

Ieșire

 Funcție derivată

Aici, am folosit o print()funcție în Baseclasă și aceeași funcție în Derivedclasă

Când apelăm print()folosind Derivedobiectul derivat1, acesta suprascrie print()funcția Basede executând print()funcția Derivedclasei.

Este un polimorfism de execuție, deoarece apelul funcției nu este rezolvat de compilator, dar este rezolvat în timp de execuție.

Pentru a afla mai multe, vizitați tutorialul nostru C ++ Function Overriding.

Funcții virtuale C ++

În C ++, este posibil să nu putem înlocui funcțiile dacă folosim un pointer din clasa de bază pentru a indica un obiect din clasa derivată.

Utilizarea funcțiilor virtuale în clasa de bază asigură că funcția poate fi anulată în aceste cazuri.

Astfel, funcțiile virtuale intră de fapt sub suprascrierea funcției . De exemplu,

 // 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.

Articole interesante...