C ++ polimorfizmus

Ebben az oktatóanyagban példák segítségével megismerhetjük a C ++ polimorfizmusát.

A polimorfizmus az objektum-orientált programozás fontos fogalma. Ez egyszerűen több formát jelent. Vagyis ugyanaz az entitás (függvény vagy operátor) másképp viselkedik a különböző forgatókönyvekben. Például,

A +C ++ operátor két speciális funkció végrehajtására szolgál. Ha számokkal (egész számokkal és lebegőpontos számokkal) használják, összeadást hajt végre.

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

Amikor pedig az +operátort húrokkal használjuk, akkor string-összefűzést végez. Például,

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

A C ++ polimorfizmust a következő módszerekkel valósíthatjuk meg:

  1. Funkció túlterhelése
  2. A kezelő túlterhelése
  3. A funkció felülbírálása
  4. Virtuális funkciók

C ++ Funkció Túlterhelés

A C ++ - ban két azonos nevű függvényt használhatunk, ha eltérő paraméterekkel (típusokkal vagy argumentumszámmal) rendelkeznek.

Az argumentumok számától / típusától függően különböző függvényeket hívnak meg. Például,

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

Kimenet

 Összeg 1 = 11 Összeg 2 = 12,1 Összeg 3 = 18

Itt 3 különböző sum()függvényt hoztunk létre , különböző paraméterekkel (paraméterek száma / típusa). És a függvényhívás során átadott argumentumok alapján egy adott részt sum()meghívunk.

Ez fordítási idejű polimorfizmus, mert a fordító a program fordítása előtt tudja, melyik függvényt kell végrehajtani.

További információért keresse fel a C ++ funkciótúlterhelés oktatóanyagunkat.

C ++ kezelő túlterhelése

A C ++ rendszerben túlterhelhetünk egy operátort, amíg a felhasználó által definiált típusokon, például objektumokon vagy struktúrákon működünk.

Nem tudjuk használni operátor túlterhelés az alaptípus, például int, doublestb

Az operátor túlterhelése alapvetően a funkció túlterhelése, ahol a különböző operátor funkciók azonos szimbólummal rendelkeznek, de különböző operandusokkal.

És az operandusoktól függően különböző operátori funkciókat hajtanak végre. Például,

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

Kimenet

 Gróf: 6

Itt túlterheltük az ++operátort, amely az Countosztály objektumain működik (ebben az esetben az objektumok száma1).

Ezt a túlterhelt operátort használtuk a count1 objektum értékváltozójának közvetlen növelésére 1.

Ez egy fordítási idejű polimorfizmus is .

További információért keresse fel a C ++ Operator Overloading oktatóanyagunkat.

C ++ Funkció felülírása

A C ++ öröklődésben ugyanolyan funkcióval rendelkezhetünk az alaposztályban, mint annak származtatott osztályaiban.

Amikor a függvényt a származtatott osztály objektumának felhasználásával hívjuk meg, a származtatott osztály függvényét hajtjuk végre az alaposztályban szereplő helyett.

Tehát a függvényt meghívó objektumtól függően különböző funkciók kerülnek végrehajtásra.

Ez az úgynevezett függvény felülírja a C ++ - ban. Például,

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

Kimenet

 Származtatott függvény

Itt használtunk egy print()függvényt az Baseosztályban, és ugyanazt a függvényt az Derivedosztályban

Amikor print()a Derivedderivált1 objektumot használjuk, akkor az osztály függvényének végrehajtásával felülírja a print()függvényt .Baseprint()Derived

Ez egy futásidejű polimorfizmus , mert a függvényhívás nem oldja meg a fordító, de ez megoldódott a futási helyett.

További információért keresse fel a C ++ Function Overriding oktatóanyagunkat.

C ++ virtuális funkciók

A C ++ nyelven előfordulhat, hogy nem tudjuk felülírni a függvényeket, ha az alaposztály mutatójával használjuk a származtatott osztály objektumát.

A virtuális függvények használata az alaposztályban biztosítja a funkció felülírását ezekben az esetekben.

Így a virtuális függvények tulajdonképpen a funkciók felülbírálása alá esnek . Például,

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

érdekes cikkek...