C ++ polimorfizmus példával

Tartalomjegyzék:

Anonim

Mi a polimorfizmus a C ++ - ban?

A C ++ - ban a polimorfizmus arra készteti a tagfunkciót, hogy másképp viselkedjen az őt meghívó / meghívó objektum alapján. A polimorfizmus görög szó, amely azt jelenti, hogy sokféle formája van. Akkor fordul elő, ha az örökléssel kapcsolatos osztályok hierarchiája van.

Tegyük fel például, hogy megvan a makeSound () függvény. Amikor egy macska meghívja ezt a funkciót, akkor nyávogás hangot ad ki. Amikor egy tehén ugyanazt a funkciót hívja meg, ez biztosítja a moow hangot.

Noha van egy funkciónk, különböző körülmények között másképp viselkedik. A függvénynek számos formája van; így elértük a polimorfizmust.

Ebben a C ++ oktatóanyagban megtudhatja:

  • Mi a polimorfizmus?
  • A polimorfizmus típusai
  • Időpolimorfizmus összeállítása
  • Funkció Túlterhelés
  • Üzemeltető túlterhelése
  • Futásidejű polimorfizmus
  • Funkció felülírása
  • C ++ virtuális funkció
  • Compile-Time Polymorphism Vs. Futásidejű polimorfizmus

A polimorfizmus típusai

A C ++ kétféle polimorfizmust támogat:

  • Compile-time polimorfizmus, és
  • Futásidejű polimorfizmus.

Időpolimorfizmus összeállítása

A túlterhelt függvényeket az argumentumok számának és típusának egyeztetésével hívja meg. Az információ a fordítási idő alatt van jelen. Ez azt jelenti, hogy a C ++ fordító fordításkor kiválasztja a megfelelő funkciót.

A fordítási idejű polimorfizmust a funkció túlterhelésével és a kezelő túlterhelésével érjük el.

Funkció Túlterhelés

A függvények túlterhelése akkor fordul elő, ha sok hasonló nevű, de eltérő argumentumú függvényünk van. Az érvek számukban vagy típusukban eltérhetnek.

1. példa:

#include using namespace std;void test(int i) {cout << " The int is " << i << endl;}void test(double f) {cout << " The float is " << f << endl;}void test(char const *ch) {cout << " The char* is " << ch << endl;}int main() {test(5);test(5.5);test("five");return 0;}

Kimenet:

Itt van egy képernyőkép a kódról:

Kód Magyarázat:

  1. Illessze be az iostream fejlécfájlt a kódunkba. Képesek leszünk használni a funkcióit.
  2. Foglalja be az standard névteret a kódunkba. Osztályait anélkül is használhatjuk, hogy felhívnánk.
  3. Hozzon létre egy teszt nevű függvényt, amely egy egész i paramétert vesz fel. A {a funkcióteszt kezdetét jelöli.
  4. A fenti függvényteszt meghívásakor végrehajtandó utasítás.
  5. A fenti funkcióteszt törzsének vége.
  6. Hozzon létre egy teszt nevű függvényt, amely egy úszó f paramétert vesz fel. A {a funkcióteszt kezdetét jelöli.
  7. A fenti függvényteszt meghívásakor végrehajtandó utasítás.
  8. A fenti funkcióteszt törzsének vége.
  9. Hozzon létre egy teszt nevű függvényt, amely ch karakterparamétert vesz fel. A {a funkcióteszt kezdetét jelöli.
  10. A fenti függvényteszt meghívásakor végrehajtandó utasítás.
  11. A fenti funkcióteszt törzsének vége.
  12. Hívja meg a main () függvényt. A {a függvény törzsének kezdetét jelöli.
  13. Hívja meg a függvénytesztet, és adja hozzá az argumentum értékeként az 5-öt. Ez meghívja a tesztfunkciót, amely elfogad egy egész argumentumot, vagyis az első tesztfüggvényt.
  14. Hívja meg a függvénytesztet, és adja át az 5.5 értéket az argumentum értékeként. Ez meghívja a tesztfunkciót, amely elfogad egy úszó argumentumot, vagyis a második tesztfüggvényt.
  15. Hívja meg a függvénytesztet, és adja hozzá ötöt az argumentum értékeként. Ez meghívja a tesztfüggvényt, amely elfogadja a karakter argumentumot, vagyis a harmadik tesztfüggvényt.
  16. A programnak vissza kell adnia egy értéket, ha sikeresen fut.
  17. A fő () függvény törzsének vége.

Három függvényünk van, azonos névvel, de különböző típusú argumentumokkal. Elértük a polimorfizmust.

Üzemeltető túlterhelése

Az Operátor túlterhelése részben meghatározunk egy új jelentést egy C ++ operátor számára. Ez megváltoztatja az operátor működését is. Például meghatározhatjuk a + operátort két karakterlánc összefűzéséhez. A számértékek összeadásának addíciós operátoraként ismerjük. Meghatározásunk után, egész számok közé helyezve hozzáadja őket. A húrok közé helyezve összefűzi őket.

2. példa:

#includeusing namespace std;class ComplexNum {private:int real, over;public:ComplexNum(int rl = 0, int ov = 0) {real = rl;over = ov;}ComplexNum operator + (ComplexNum const &obj) {ComplexNum result;result.real = real + obj.real;result.over = over + obj.over;return result;}void print() {cout << real << " + i" << over << endl;}};int main(){ComplexNum c1(10, 2), c2(3, 7);ComplexNum c3 = c1+c2;c3.print();}

Kimenet:

Itt van egy képernyőkép a kódról:

Kód Magyarázat:

  1. Felvegye az iostream fejléc fájlt programunkba annak funkcióinak használata érdekében.
  2. Vegyük be az std névteret programunkba annak érdekében, hogy az osztályait hívás nélkül használhassuk.
  3. Hozzon létre egy ComplexNum nevű osztályt. A {az osztálytest kezdetét jelöli.
  4. A privát hozzáférés módosítóval jelölje meg a változókat privátként, vagyis csak az osztályon belül érhetők el.
  5. Határozzon meg két egész számot, valós és több.
  6. A nyilvános hozzáférés módosítójával jelölje meg a kivitelezőt nyilvánosként, vagyis még az osztályon kívülről is elérhető lesz.
  7. Hozza létre az osztály konstruktort és inicializálja a változókat.
  8. Inicializálja a valós változó értékét.
  9. Inicializálja a változó értékét.
  10. A konstruktortest vége.
  11. Felül kell írnunk a + operátor jelentését.
  12. Hozza létre a ComplexNum típusú adattípus eredményt.
  13. Használja a + operátort összetett számokkal. Ez a sor hozzáadja a szám valós részét egy másik szám valós részéhez.
  14. Használja a + operátort összetett számokkal. Ez a vonal hozzáadja a szám képzeletbeli részét egy másik szám képzeletbeli részéhez.
  15. A program a sikeres végrehajtás után visszaadja a változó eredményét.
  16. A + operátor új jelentésének, vagyis a túlterhelés definíciójának vége.
  17. Hívja meg a print () metódust.
  18. A konzolra történő hozzáadás után nyomtassa ki az új komplex számot.
  19. A törzs () funkció vége.
  20. A ComplexNum osztály testének vége.
  21. Hívja meg a main () függvényt.
  22. Adja át a hozzáadandó valós és összetett részek értékeit. A c1 első része hozzáadódik a c2 első részéhez, vagyis 10 + 3. A c1 második része hozzáadódik a c második részéhez, vagyis 2 + 7.
  23. Hajtson végre egy műveletet a túlterhelt + operátor segítségével, és az eredményt tárolja a c3 változóba.
  24. Nyomtassa ki a c3 változó értékét a konzolra.
  25. A fő () függvény törzsének vége.

Futásidejű polimorfizmus

Ez akkor történik, amikor az objektum metódusát futás közben, és nem fordítási idő alatt hívják meg / hívják meg. A futásidejű polimorfizmus a funkció felülírása révén érhető el. A meghívandó / meghívandó funkció futás közben jön létre.

Funkció felülírása

A függvény felülbírálása akkor fordul elő, ha az alaposztály függvényének új meghatározást adunk a származtatott osztályban. Akkor azt mondhatjuk, hogy az alapfunkciót felülbírálták.

Például:

#include using namespace std;class Mammal {public:void eat() {cout << "Mammals eat… ";}};class Cow: public Mammal {public:void eat() {cout << "Cows eat grass… ";}};int main(void) {Cow c = Cow();c.eat();return 0;}

Kimenet:

Itt van egy képernyőkép a kódról:

Kód Magyarázat:

  1. Importálja az iostream fejlécfájlt a programunkba a funkcióinak használatához.
  2. Vegyük be az std névteret programunkba annak érdekében, hogy az osztályait hívás nélkül használhassuk.
  3. Hozzon létre egy emlős nevű osztályt. A {az osztálytest kezdetét jelöli.
  4. A nyilvános hozzáférés módosítójával állítsa be a létrehozni kívánt funkciót nyilvánosan hozzáférhetővé. Ezen az osztályon kívülről lesz elérhető.
  5. Hozzon létre egy nyilvános funkciót, amelynek neve: eat. A {a függvénytest kezdetét jelöli.
  6. Nyomtassa ki a cout függvényhez adott utasítást, amikor az eat () függvényt meghívja.
  7. A funkciótest vége enni ().
  8. Az emlős osztály testének vége.
  9. Hozzon létre egy Tehén nevű osztályt, amely örökli az emlős osztályt. A tehén a származtatott osztály, míg az emlős az alaposztály. A {jelöli ennek az osztálynak a kezdetét.
  10. A nyilvános hozzáférés módosítóval jelölje meg a létrehozni kívánt funkciót nyilvánosan hozzáférhetőként. Ezen az osztályon kívülről lesz elérhető.
  11. Felülbírálja az eat () függvényt, amelyet az alaposztály definiált. A {a függvénytest kezdetét jelöli.
  12. A konzolra nyomtatandó utasítás, amikor ezt a függvényt meghívják.
  13. A függvény testének vége enni ().
  14. Tehén osztály testének vége.
  15. Hívja meg a main () függvényt. A {a függvény törzsének kezdetét jelöli.
  16. Hozzon létre egy példát a Tehén osztályból, és adja meg neki a c nevet.
  17. Hívja meg a Tehén osztályban definiált eat () függvényt.
  18. A programnak eredményt kell adnia a sikeres befejezés után.
  19. A fő () függvény vége.

C ++ virtuális funkció

A virtuális függvény egy másik módja a futási idejű polimorfizmus C ++ - ban történő megvalósításának. Ez egy speciális funkció, amelyet egy alaposztályban definiálnak, és a származtatott osztályban definiálnak újra. Virtuális függvény deklarálásához használja a virtuális kulcsszót. A kulcsszónak meg kell előznie a függvény deklarálását az alaposztályban.

Ha egy virtuális függvényosztály öröklődik, a virtuális osztály újradefiniálja a virtuális függvényt az igényeinek megfelelően. Például:

#include using namespace std;class ClassA {public:virtual void show() {cout << "The show() function in base class invoked… " << endl;}};class ClassB :public ClassA {public:void show() {cout << "The show() function in derived class invoked… ";}};int main() {ClassA* a;ClassB b;a = &b;a->show();}

Kimenet:

Itt van egy képernyőkép a kódról:

Kód Magyarázat:

  1. Foglalja be az iostream fejléc fájlt a kódba a funkcióinak használatához.
  2. Vegye fel az std névteret a kódunkba, hogy az osztályait hívás nélkül használhassa.
  3. Hozzon létre egy ClassA nevű osztályt.
  4. A nyilvános hozzáférés módosítójával jelölje meg az osztály tagját nyilvánosan hozzáférhetőként.
  5. Hozzon létre egy show () nevű virtuális függvényt. Nyilvános funkció lesz.
  6. A show () meghívásakor kinyomtatandó szöveg. Az endl egy C ++ kulcsszó, ami végvonalat jelent. Az egérmutatót a következő sorra mozgatja.
  7. A virtuális függvény show törzsének vége ().
  8. Az A osztály felépítményének vége.
  9. Új ClassB nevű osztály létrehozása, amely örökli az A osztályt. Az A osztály lesz az alaposztály, míg a B. osztály lesz a származtatott osztály.
  10. A nyilvános hozzáférés módosítójával jelölje meg az osztály tagját nyilvánosan hozzáférhetőként.
  11. Újra definiálja az alaposztályból származtatott virtuális függvény show () -t.
  12. A konzolra nyomtatandó szöveg a származtatott osztályban definiált show () függvény meghívásakor.
  13. A show () függvény törzsének vége.
  14. A származtatott osztály törzsének vége, B. osztály.
  15. Hívja meg a main () függvényt. A program logikáját hozzá kell adni a törzséhez.
  16. Hozzon létre egy a nevű mutatóváltozót. A ClassA nevű osztályra mutat.
  17. Hozzon létre egy példányt a ClassB nevű osztályból. A példány b nevet kap.
  18. Rendelje hozzá az a változó b címének értéktárolóit.
  19. Hívja meg a származtatott osztályban definiált show () függvényt. Késői kötés valósult meg.
  20. A fő () függvény törzsének vége.

Compile-Time Polymorphism Vs. Futásidejű polimorfizmus

Itt vannak a kettő közötti fő különbségek:

Compile-time polimorfizmus Futásidejű polimorfizmus
Korai kötődésnek vagy statikus polimorfizmusnak is nevezik Késői / dinamikus kötődésnek vagy dinamikus polimorfizmusnak is nevezik
A metódust fordítási idő alatt hívják meg / hívják meg A metódust futás közben hívják meg / hívják meg
Funkció túlterhelés és a kezelő túlterhelés révén valósul meg Módszeres felülbíráló és virtuális függvényekkel valósítható meg
Példa, módszer túlterhelése. Sok módszernek lehet hasonló neve, de eltérő számú vagy típusú argumentum Példa, módszer felülírása. Sok módszernek lehet hasonló neve és prototípusa.
Gyorsabb végrehajtás, mivel a módszerek felfedezése fordítási idő alatt történik Lassabb végrehajtás, mivel a metódus felfedező futás közben történik.
Kevesebb rugalmasságot biztosít a problémamegoldáshoz, mivel a fordítás ideje alatt minden ismert. Nagy rugalmasságot biztosítanak a komplex problémák megoldásához, mivel a módszereket futás közben fedezik fel.

Összegzés:

  • A polimorfizmus azt jelenti, hogy sokféle formája van.
  • Akkor fordul elő, amikor az örökléssel kapcsolatos osztályok hierarchiája létezik.
  • A polimorfizmus esetén a függvény másképp viselkedhet a meghívó / hívó objektum alapján.
  • A fordítási idő polimorfizmusában a meghívandó funkció a fordítási idő alatt jön létre.
  • Futásidejű polimorfizmusban a meghívandó funkció futás közben jön létre.
  • A fordítási idejű polimorfizmust a funkció túlterhelése és a kezelő túlterhelése határozza meg.
  • A függvények túlterhelésében sok hasonló nevű, de eltérő argumentumú függvény létezik.
  • A paraméterek számban vagy típusban különbözhetnek.
  • Az operátor túlterhelésében új jelentést határoz meg a C ++ operátorok számára.
  • A futásidejű polimorfizmus a funkció felülírása révén érhető el.
  • A függvény felülbírálásakor egy származtatott osztály új definíciót ad az alaposztályban definiált függvénynek.