Het woord polymorfisme betekent dat er vele vormen zijn. In eenvoudige bewoordingen kunnen we polymorfisme definiëren als het vermogen van een bericht om in meer dan één vorm te worden weergegeven. Een praktijkvoorbeeld van polymorfisme is een persoon die tegelijkertijd verschillende kenmerken kan hebben. Een man is tegelijkertijd vader, echtgenoot en werknemer. Dezelfde persoon vertoont dus verschillend gedrag in verschillende situaties. Dit heet polymorfisme. Polymorfisme wordt beschouwd als een van de belangrijke kenmerken van objectgeoriënteerd programmeren.
Soorten polymorfisme
- Compile-time polymorfisme
- Runtime-polymorfisme
Soorten polymorfisme
1. Compile-time polymorfisme
Dit type polymorfisme wordt bereikt door overbelasting van functies of overbelasting van operators.
A. Functieoverbelasting
Als er meerdere functies zijn met dezelfde naam maar verschillende parameters, dan wordt gezegd dat de functies dat zijn overbelast, vandaar dat dit bekend staat als functie-overbelasting. Functies kunnen overbelast raken door het aantal argumenten wijzigen of en het veranderen van het type argumenten . Simpel gezegd is het een kenmerk van objectgeoriënteerd programmeren dat veel functies biedt die dezelfde naam hebben, maar verschillende parameters wanneer er meerdere taken onder één functienaam worden vermeld. Er zijn bepaalde regels voor functieoverbelasting die moeten worden gevolgd bij het overbelasten van een functie.
Hieronder staat het C++-programma om functie-overbelasting of polymorfisme tijdens het compileren weer te geven:
C++
// C++ program to demonstrate> // function overloading or> // Compile-time Polymorphism> #include> using> namespace> std;> class> Geeks {> public>:> >// Function with 1 int parameter> >void> func(>int> x)> >{> >cout <<>'value of x is '> << x << endl;> >}> >// Function with same name but> >// 1 double parameter> >void> func(>double> x)> >{> >cout <<>'value of x is '> << x << endl;> >}> >// Function with same name and> >// 2 int parameters> >void> func(>int> x,>int> y)> >{> >cout <<>'value of x and y is '> << x <<>', '> << y> ><< endl;> >}> };> // Driver code> int> main()> {> >Geeks obj1;> >// Function being called depends> >// on the parameters passed> >// func() is called with int value> >obj1.func(7);> >// func() is called with double value> >obj1.func(9.132);> >// func() is called with 2 int values> >obj1.func(85, 64);> >return> 0;> }> |
>
Java-stapels
>Uitvoer
value of x is 7 value of x is 9.132 value of x and y is 85, 64>
Uitleg: In het bovenstaande voorbeeld is dit een enkele functie met de naam function func() gedraagt zich anders in drie verschillende situaties, wat een eigenschap is van polymorfisme. Om hier meer over te weten, kunt u het artikel raadplegen: Functie-overbelasting in C++ .
B. Overbelasting van de machinist
C++ heeft de mogelijkheid om de operators een speciale betekenis te geven voor een gegevenstype. Deze mogelijkheid staat bekend als operator-overbelasting. We kunnen bijvoorbeeld gebruik maken van de opteloperator (+) voor de stringklasse om twee strings samen te voegen. We weten dat het de taak van deze operator is om twee operanden op te tellen. Dus een enkele operator ‘+’, wanneer deze tussen integer-operands wordt geplaatst, voegt ze toe en wanneer deze tussen string-operands wordt geplaatst, voegt hij ze samen.
Hieronder vindt u het C++-programma om overbelasting door operators aan te tonen:
CPP
teken om Java te stringen
// C++ program to demonstrate> // Operator Overloading or> // Compile-Time Polymorphism> #include> using> namespace> std;> class> Complex {> private>:> >int> real, imag;> public>:> >Complex(>int> r = 0,>int> i = 0)> >{> >real = r;> >imag = i;> >}> >// This is automatically called> >// when '+' is used with between> >// two Complex objects> >Complex operator+(Complex>const>& obj)> >{> >Complex res;> >res.real = real + obj.real;> >res.imag = imag + obj.imag;> >return> res;> >}> >void> print() { cout << real <<>' + i'> << imag << endl; }> };> // Driver code> int> main()> {> >Complex c1(10, 5), c2(2, 4);> >// An example call to 'operator+'> >Complex c3 = c1 + c2;> >c3.print();> }> |
>
>Uitvoer
12 + i9>
Uitleg: In het bovenstaande voorbeeld is de operator ‘+’ overbelast. Meestal wordt deze operator gebruikt om twee getallen op te tellen (gehele getallen of getallen met drijvende komma), maar hier wordt de operator gebruikt om de optelling van twee denkbeeldige of complexe getallen uit te voeren. Raadpleeg het artikel voor meer informatie hierover: Overbelasting van de machinist .
2. Runtime-polymorfisme
Dit type polymorfisme wordt bereikt door Functie overschrijven . Late binding en dynamisch polymorfisme zijn andere namen voor runtime-polymorfisme. De functieaanroep wordt tijdens runtime opgelost in runtime-polymorfisme . Bij compileerpolymorfisme daarentegen bepaalt de compiler welke functieaanroep aan het object moet worden gekoppeld nadat deze tijdens runtime is afgeleid.
A. Functie overschrijven
Functie overschrijven treedt op wanneer een afgeleide klasse een definitie heeft voor een van de lidfuncties van de basisklasse. Er wordt gezegd dat die basisfunctie wordt overschreven.
Functie overschrijven Uitleg
Runtimepolymorfisme met gegevensleden
Runtime-polymorfisme kan niet worden bereikt door gegevensleden in C++. Laten we een voorbeeld bekijken waarin we toegang krijgen tot het veld via de referentievariabele van de bovenliggende klasse die verwijst naar de instantie van de afgeleide klasse.
afrekenen in git
C++
// C++ program for function overriding with data members> #include> using> namespace> std;> // base class declaration.> class> Animal {> public>:> >string color =>'Black'>;> };> // inheriting Animal class.> class> Dog :>public> Animal {> public>:> >string color =>'Grey'>;> };> // Driver code> int> main(>void>)> {> >Animal d = Dog();>// accessing the field by reference> >// variable which refers to derived> >cout << d.color;> }> |
>
>Uitvoer
statisch trefwoord in Java
Black>
We kunnen zien dat de verwijzing naar de ouderklasse altijd verwijst naar het gegevenslid van de ouderklasse.
B. Virtuele functie
A virtuele functie is een lidfunctie die in de basisklasse wordt gedeclareerd met behulp van het trefwoord virtueel en opnieuw wordt gedefinieerd (overschreven) in de afgeleide klasse.
Enkele belangrijke punten over virtuele functies:
- Virtuele functies zijn dynamisch van aard.
- Ze worden gedefinieerd door het trefwoord in te voegen virtueel binnen een basisklasse en worden altijd gedeclareerd met een basisklasse en overschreven in een onderliggende klasse
- Tijdens Runtime wordt een virtuele functie aangeroepen
Hieronder vindt u het C++-programma om de virtuele functie te demonstreren:
C++
// C++ Program to demonstrate> // the Virtual Function> #include> using> namespace> std;> // Declaring a Base class> class> GFG_Base {> public>:> >// virtual function> >virtual> void> display()> >{> >cout <<>'Called virtual Base Class function'> ><<>'
'>;> >}> >void> print()> >{> >cout <<>'Called GFG_Base print function'> ><<>'
'>;> >}> };> // Declaring a Child Class> class> GFG_Child :>public> GFG_Base {> public>:> >void> display()> >{> >cout <<>'Called GFG_Child Display Function'> ><<>'
'>;> >}> >void> print()> >{> >cout <<>'Called GFG_Child print Function'> ><<>'
'>;> >}> };> // Driver code> int> main()> {> >// Create a reference of class GFG_Base> >GFG_Base* base;> >GFG_Child child;> >base = &child;> >// This will call the virtual function> >base->GFG_Base::display();> >// this will call the non-virtual function> >base->print();> }> |
>
>Uitvoer
Called virtual Base Class function Called GFG_Base print function>
Voorbeeld 2:
C++
tekenreeks in c
// C++ program for virtual function overriding> #include> using> namespace> std;> class> base {> public>:> >virtual> void> print()> >{> >cout <<>'print base class'> << endl;> >}> >void> show() { cout <<>'show base class'> << endl; }> };> class> derived :>public> base {> public>:> >// print () is already virtual function in> >// derived class, we could also declared as> >// virtual void print () explicitly> >void> print() { cout <<>'print derived class'> << endl; }> >void> show() { cout <<>'show derived class'> << endl; }> };> // Driver code> int> main()> {> >base* bptr;> >derived d;> >bptr = &d;> >// Virtual function, binded at> >// runtime (Runtime polymorphism)> >bptr->print();> >// Non-virtual function, binded> >// at compile time> >bptr->toon();> >return> 0;> }> |
>
>Uitvoer
print derived class show base class>