Menu

Polymorfismus v C ++

polymorphism c

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

Role polymorfismu v C ++ s příklady.

jak otevřít soubor a.dat na macu

Polymorfismus je jedním ze čtyř pilířů objektového programování. Polymorfismus znamená mít mnoho forem. Lze jej definovat jako techniku, kterou může mít objekt v závislosti na situaci mnoho podob.

Z programového hlediska můžeme říci, že objekt se může za různých podmínek chovat odlišně.

V tomto tutoriálu se podrobně seznámíme s typy polymorfismu, způsoby implementace polymorfismu spolu s různými dalšími pojmy polymorfismu.

=> Podívejte se sem a podívejte se zde na A-Z výukových kurzů C ++.

Polymorfismus v C ++

Například, žena může mít mnoho rolí v různých situacích. Pro dítě je to matka, žena v domácnosti, pracovník v kanceláři atd. Žena tedy zaujímá různé role a projevuje odlišné chování v různých podmínkách. Toto je skutečný příklad polymorfismu.

Podobně ve světě programování také můžeme mít operátor „+“, což je operátor binárního přidání, který se chová odlišně, když se operandy změní. Například, když jsou oba operandy číselné, provede sčítání.

Na druhou stranu, když jsou operandy řetězec, funguje jako operátor zřetězení. Polymorfismus tedy v kostce znamená entitu, která zabírá různé formy nebo se za různých podmínek chová odlišně.

Co se naučíte:

Druhy polymorfismu

Polymorfismus se dělí na dva typy.

  • Zkompilovat časový polymorfismus
  • Runtime polymorfismus

Schéma, které to představuje, je uvedeno níže:

Druhy polymorfismu

Jak je znázorněno ve výše uvedeném diagramu, polymorfismus je rozdělen na polymorfismus v době kompilace a runtime polymorfismus. Polymorfismus času kompilace se dále dělí na přetížení operátora a přetížení funkce. Runtime polymorfismus je dále implementován pomocí virtuálních funkcí.

Polymorfismus času kompilace je také známý jako časný vazebný nebo statický polymorfismus. U tohoto typu polymorfismu je metoda objektu vyvolána v době kompilace. V případě běhového polymorfismu je metoda objektu vyvolána za běhu.

Runtime polymorfismus je také známý jako dynamický nebo pozdní vazba nebo dynamický polymorfismus. Podrobnou implementaci každé z těchto technik prozkoumáme v následujících tématech.

Kompilace časového polymorfismu vs. Polymorfismus za běhu

Níže se podívejme na hlavní rozdíly mezi časem kompilace a běhovým polymorfismem.

Zkompilovat časový polymorfismusRuntime polymorfismus
Také známý jako statický polymorfismus nebo časná vazbaTaké známý jako dynamický polymorfismus nebo pozdní / dynamická vazba
Metoda objektů je vyvolána v době kompilaceMetoda objektu je vyvolána za běhu
Obvykle implementováno pomocí přetížení operátora a přetížení funkceImplementováno pomocí virtuálních funkcí a přepsání metod
Přetížení metody je polymorfismus v době kompilace, ve kterém může mít více než jedna metoda stejný název, ale odlišný seznam a typy parametrů.Přepsání metody je runtime polymorfismus, kdy více než jedna metoda má stejný název se stejným prototypem
Protože metody jsou známé v době kompilace, je provádění rychlejšíProvádění je pomalejší, protože metoda je známá za běhu
Poskytují menší flexibilitu při implementaci řešení, protože vše je třeba znát v době kompilaceDaleko flexibilnější pro implementaci komplexních řešení, protože metody se rozhodují za běhu

Kompilace časového polymorfismu

Polymorfismus v čase kompilace je technika, při které je metoda objektu vyvolána v době kompilace.

Tento typ polymorfismu je implementován dvěma způsoby.

  • Přetížení funkce
  • Přetížení obsluhy

Budeme podrobně diskutovat o každé technice.

Přetížení funkce

O funkci se říká, že je přetížená, když máme více než jednu funkci se stejným názvem, ale různými typy parametrů nebo jiným počtem argumentů.

Funkce tedy může být přetížena na základě typů parametrů, pořadí parametrů a počtu parametrů.

Všimněte si, že dvě funkce, které mají stejný název a stejný seznam parametrů, ale odlišný návratový typ, nejsou přetíženou funkcí a při použití v programu budou mít za následek chybu kompilace.

Podobně, když se parametry funkce liší pouze v ukazateli a pokud je typ pole ekvivalentní, neměl by se používat k přetížení.

Jiné typy jako statické a nestatické, konstantní a těkavé atd. Nebo deklarace parametrů, které se liší v přítomnosti nebo nepřítomnosti výchozích hodnot, se také nepoužívají pro přetížení, protože jsou ekvivalentní z hlediska implementace.

Například,následující prototypy funkcí jsou přetížené funkce.

Add(int,int); Add(int,float); Add(float,int); Add(int,int,int);

Ve výše uvedených prototypech vidíme, že přetížíme funkci Add na základě typu parametrů, pořadí nebo pořadí parametrů, počtu parametrů atd.

Vezměme si kompletní programovací příklad, abychom lépe porozuměli přetížení funkcí.

#include #include using namespace std; class Summation { public: int Add(int num1,int num2) { return num1+num2; } int Add(int num1,int num2, int num3) { return num1+num2+num3; } string Add(string s1,string s2){ return s1+s2; } }; int main(void) { Summation obj; cout<

Výstup:

35
191
19
Ahoj světe

software ke stažení videí na trubici

Ve výše uvedeném programu máme Summation třídu, která definovala tři přetížené funkce s názvem Add, která přebírá dva celočíselné argumenty, tři celočíselné argumenty a dva řetězcové argumenty.

V hlavní funkci provádíme čtyři volání funkcí, která poskytují různé parametry. První dvě volání funkcí jsou přímočará. Ve třetím volání funkce Add poskytujeme dvě hodnoty s plovoucí desetinnou čárkou jako argumenty.

V tomto případě je funkce, která je spárována, int Add (int, int) jako interně, float je převeden na double a poté spárován s funkcí s parametry int. Pokud bychom místo float zadali double, pak bychom měli další přetíženou funkci s double as parametry.

Poslední volání funkce používá jako parametry řetězcové hodnoty. V tomto případě operátor Add (+) funguje jako operátor zřetězení a zřetězí dvě hodnoty řetězce, aby vytvořil jeden řetězec.

Výhody přetížení funkce

Hlavní výhodou přetížení funkce je to, že podporuje opětovné použití kódu. Můžeme mít co nejvíce funkcí se stejným názvem, pokud jsou přetíženy na základě typu argumentu, sekvence argumentů a počtu argumentů.

Tímto způsobem je snazší mít různé funkce se stejným názvem, které představují chování stejné operace v různých podmínkách.

Pokud by přetížení funkce nebylo k dispozici, museli bychom psát příliš mnoho různých druhů funkcí s různými názvy, čímž by byl kód nečitelný a obtížně se přizpůsobil.

Přetížení operátora

Přetížení operátorů je technika, pomocí které dáváme jiný význam existujícím operátorům v C ++. Jinými slovy, přetížíme operátory, abychom dali uživatelským datovým typům jako objektům zvláštní význam.

Většina operátorů v C ++ je přetížená nebo jim byl přidělen zvláštní význam, aby mohli pracovat na uživatelem definovaných datových typech. Všimněte si, že při přetížení se základní operace operátorů nezmění. Přetížení dává operátorovi další význam tím, že jeho základní sémantika zůstane stejná.

Ačkoli většinu operátorů lze v C ++ přetížit, existují některé operátory, které nelze přetížit.

Tito operátoři jsou uvedeni v tabulce níže.

Operátoři
Operátor rozlišení oboru (: :)
Velikost
výběr členů (.)
selektor ukazatele člena (*)
ternární operátor (? :)

Funkce, které používáme k přetížení operátorů, se nazývají „ Funkce operátora “.

Funkce operátora jsou podobné normálním funkcím, ale s rozdílem. Rozdíl je v tom, že název funkcí operátora začíná klíčovým slovem „ operátor ”Následovaný symbolem operátoru, který má být přetížen.

Funkce operátoru je poté vyvolána, když je v programu použit odpovídající operátor. Těmito operátorskými funkcemi mohou být členské funkce nebo globální metody nebo dokonce funkce přátel.

Obecná syntaxe funkce operátora je:

return_type classname::operator op(parameter list) { //function body }

Zde „operátor op“ je funkce operátoru, kde operátor je klíčové slovo a op je operátor, který má být přetížen. Return_type je typ hodnoty, který se má vrátit.

Podívejme se na několik příkladů programování, abychom demonstrovali přetížení operátoru pomocí funkcí operátora.

Příklad 1:Přetížení unárního operátoru pomocí funkce člena operátora.

#include using namespace std; class Distance { public: int feet; // Constructor to initialize the object's value Distance(int feet) { this->feet = feet; } //operator function to overload ++ operator to perform increment on Distance obj void operator++() { feet++; } void print(){ cout << ' Incremented Feet value: ' << feet; } }; int main() { Distance d1(9); // Use (++) unary operator ++d1; d1.print(); return 0; }

Výstup:

Hodnota zvýšených stop: 10

Zde jsme přetížili unární operátor přírůstku pomocí funkce operator ++. V hlavní funkci používáme tento ++ operátor pro zvýšení objektu třídy Distance.

Příklad 2:Přetížení binárního operátoru pomocí funkce člena operátora.

#include using namespace std; class Complex { int real, imag; public: Complex(int r = 0, int i =0) {real = r; imag = i;} //Operator function to overload binary + to add two complex numbers Complex operator + (Complex const &obj) { Complex c3; c3.real = real + obj.real; c3.imag = imag + obj.imag; return c3; } void print() { cout << real << ' + i' << imag << endl; } }; int main() { Complex c1(2, 5), c2(3, 7); cout<<'c1 = '; c1.print(); cout<<'c2 = '; c2.print(); cout<<'c3 = c1+c2 = '; Complex c3 = c1 + c2; // calls overloaded + operator c3.print(); }

Výstup:

c1 = 2 + i5
c2 = 3 + i7
c3 = c1 + c2 = 5 + i12

Zde jsme použili klasický příklad přidání dvou komplexních čísel pomocí přetížení operátoru. Definujeme třídu, která představuje komplexní čísla, a operátorovou funkci na přetížení + operátor, do které přidáme skutečnou a imaginární část komplexních čísel.

V hlavní funkci deklarujeme dva složité objekty a přidáme je pomocí přetíženého + operátoru, abychom získali požadovaný výsledek.

V níže uvedeném příkladu použijeme funkci friend k přidání dvou komplexních čísel, abychom viděli rozdíl v implementaci.

#include using namespace std; class Complex { int real, imag; public: Complex(int r = 0, int i =0) {real = r; imag = i;} //friend function to overload binary + to add two complex numbers friend Complex operator +(Complex const &, Complex const &); void print() { cout << real << ' + i' << imag << endl; } }; Complex operator + (Complex const &c1, Complex const &c2) { Complex c3; c3.real = c1.real + c2.real; c3.imag = c1.imag + c2.imag; return c3; } int main() { Complex c1(2, 5), c2(3, 7); cout<<'c1 = '; c1.print(); cout<<'c2 = '; c2.print(); cout<<'c3 = c1+c2 = '; Complex c3 = c1 + c2; // calls overloaded + operator c3.print(); }

Výstup:

c1 = 2 + i5
c2 = 3 + i7
c3 = c1 + c2 = 5 + i12

Vidíme, že výstup programu je stejný. Jediným rozdílem v implementaci je použití funkce friend k přetížení operátoru + namísto členské funkce v předchozí implementaci.

Když se pro binární operátor používá funkce friend, musíme funkci explicitně zadat oba operandy. Podobně, když je unární operátor přetížen pomocí funkce friend, musíme funkci poskytnout jediný operand.

jak najít soubory apk na tabletu Android

Kromě funkcí operátoru můžeme také napsat a operátor převodu který se používá k převodu z jednoho typu na jiný. Tyto přetížené operátory převodu by měly být členskou funkcí třídy.

Příklad 3:Přetížení operátoru pomocí operátoru převodu.

#include using namespace std; class DecFraction { int numerator, denom; public: DecFraction(int num, int denm) { numerator = num; denom = denm; } // conversion operator: converts fraction to float value and returns it operator float() const { return float(numerator) / float(denom); } }; int main() { DecFraction df(3, 5); //object of class float res_val = df; //calls conversion operator cout << 'The resultant value of given fraction (3,5)= '<

Výstup:

Výsledná hodnota daného zlomku (3,5) = 0,6

V tomto programu jsme použili operátor převodu k převodu dané frakce na floatovou hodnotu. Po dokončení převodu operátor převodu vrátí výslednou hodnotu volajícímu.

Když v hlavní funkci přiřadíme objekt df proměnné res_val, dojde k převodu a výsledek se uloží do res_val.

Můžeme také volat konstruktor s jediným argumentem. Když můžeme volat konstruktor z třídy pomocí jediného argumentu, nazývá se to „ konverze stavitel “. Konstruktor převodu lze použít pro implicitní převod na vytvářenou třídu.

#include using namespace std; class Point { private: int x,y; public: Point(int i=0,int j=0) {x = i;y=j;} void print() { cout<<' x = '<

Výstup:

Bod konstruovaný pomocí normálního konstruktoru
x = 20 y = 30
Bod konstruovaný pomocí konstruktoru převodu
x = 10 y = 0

Výstup přetížení Operartor

Zde máme třídu Point, která definuje konstruktor s výchozími hodnotami. V hlavní funkci vytvoříme objekt pt se souřadnicemi xay. Dále jen přiřadíme pt hodnotu 10. Zde se nazývá konstruktor převodu a x je přiřazena hodnota 10, zatímco y je dána výchozí hodnota 0.

Pravidla přetížení operátora

Při provádění přetížení operátora si musíme dávat pozor na níže uvedená pravidla.

  • V C ++ jsme schopni přetížit pouze existující operátory. Nově přidané operátory nelze přetížit.
  • Když jsou operátory přetížené, musíme zajistit, aby alespoň jeden z operandů byl uživatelem definovaného typu.
  • K přetížení určitých operátorů můžeme využít také funkci přátel.
  • Když přetížíme unární operátory pomocí členské funkce, nebude to vyžadovat žádné explicitní argumenty. Při přetížení unárního operátoru pomocí funkce friend trvá jeden explicitní argument.
  • Podobně, když jsou binární operátory přetíženy pomocí členské funkce, musíme funkci poskytnout jeden explicitní argument. Když jsou binární operátory přetíženy pomocí funkce friend, funkce přebírá dva argumenty.
  • V C ++ jsou dva operátory, které jsou již přetížené. Jedná se o „=“ a „&“. Proto ke kopírování objektu stejné třídy nepotřebujeme přetížit operátor = a můžeme ho použít přímo.

Výhody přetížení operátora

Přetížení operátorů v C ++ nám umožňuje kromě vestavěných typů rozšířit funkčnost operátorů na uživatelem definované typy včetně objektů třídy.

Rozšířením funkčnosti operátora na uživatelem definované typy, nemusíme psát složitý kód k provádění různých operací na uživatelem definovaných typech, ale můžeme to udělat v jedné operaci samotné, stejně jako vestavěné typy.

Závěr

Polymorfismus času kompilace poskytuje možnost přetížení hlavně k rozšíření funkčnosti kódu, pokud jde o přetížení funkce a přetížení operátora.

Prostřednictvím přetížení funkce můžeme psát více než jednu funkci se stejným názvem, ale různými parametry a typy. Díky tomu je kód jednoduchý a snadno čitelný. Přetížením operátorů můžeme rozšířit funkčnost operátorů, abychom mohli provádět základní operace také na uživatelem definovaných typech.

V našem nadcházejícím tutoriálu se dozvíme více o runtime polymorfismu v C ++.

=> Přečtěte si sérii školení Easy C ++.

Doporučené čtení

^