Ordet polymorfisme betyr å ha mange former. Med enkle ord kan vi definere polymorfisme som evnen til en melding til å vises i mer enn én form. Et ekte eksempel på polymorfisme er en person som samtidig kan ha forskjellige egenskaper. En mann er samtidig en far, en ektemann og en ansatt. Så den samme personen viser ulik oppførsel i forskjellige situasjoner. Dette kalles polymorfisme. Polymorfisme regnes som en av de viktige egenskapene til objektorientert programmering.
Typer polymorfisme
- Kompileringstidspolymorfisme
- Runtime polymorfisme
Typer polymorfisme
1. Kompileringstidspolymorfisme
Denne typen polymorfisme oppnås ved funksjonsoverbelastning eller operatøroverbelastning.
A. Funksjon Overbelastning
Når det er flere funksjoner med samme navn, men forskjellige parametere, sies funksjonene å være det overbelastet, derfor er dette kjent som funksjonsoverbelastning. Funksjoner kan overbelastes av endre antall argumenter eller/og endre type argumenter . Enkelt sagt er det en funksjon ved objektorientert programmering som gir mange funksjoner som har samme navn, men forskjellige parametere når mange oppgaver er oppført under ett funksjonsnavn. Det er visse regler for funksjonsoverbelastning som bør følges ved overbelastning av en funksjon.
Nedenfor er C++-programmet for å vise funksjonsoverbelastning eller kompileringstidspolymorfisme:
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;> }> |
>
objekt for array i java
>Produksjon
value of x is 7 value of x is 9.132 value of x and y is 85, 64>
Forklaring: I eksemplet ovenfor, en enkelt funksjon kalt funksjon func() opptrer forskjellig i tre forskjellige situasjoner, noe som er en egenskap ved polymorfisme. For å vite mer om dette, kan du se artikkelen – Funksjon Overbelastning i C++ .
B. Operatør Overbelastning
C++ har muligheten til å gi operatørene en spesiell betydning for en datatype, denne evnen er kjent som operatøroverbelastning. For eksempel kan vi bruke addisjonsoperatoren (+) for strengklasse for å sette sammen to strenger. Vi vet at oppgaven til denne operatøren er å legge til to operander. Så en enkelt operator '+', når den plasseres mellom heltallsoperander, legger dem til og når de plasseres mellom strengoperander, setter de sammen.
Nedenfor er C++-programmet for å demonstrere operatøroverbelastning:
CPP
tegn til streng java
// 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();> }> |
>
>
postordregjennomgangProduksjon
12 + i9>
Forklaring: I eksemplet ovenfor er operatøren '+' overbelastet. Vanligvis brukes denne operatoren til å legge til to tall (heltall eller flyttall), men her er operatoren laget for å utføre addisjon av to imaginære eller komplekse tall. For å vite mer om denne, se artikkelen - Operatør overbelastning .
2. Runtime Polymorphism
Denne typen polymorfisme oppnås ved Funksjonsoverstyring . Sen binding og dynamisk polymorfisme er andre navn for runtime polymorfisme. Funksjonskallet løses ved kjøretid i runtime polymorfisme . I kontrast, med kompileringstidspolymorfisme, bestemmer kompilatoren hvilket funksjonskall som skal bindes til objektet etter å ha utledet det ved kjøring.
A. Overstyring av funksjoner
Funksjonsoverstyring oppstår når en avledet klasse har en definisjon for en av medlemsfunksjonene til basisklassen. Den basisfunksjonen sies å være overstyrt.
Funksjon overstyrende Forklaring
Runtime polymorfisme med datamedlemmer
Kjøretidspolymorfisme kan ikke oppnås av datamedlemmer i C++. La oss se et eksempel hvor vi får tilgang til feltet ved hjelp av referansevariabel for overordnet klasse som refererer til forekomsten av den avledede klassen.
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;> }> |
>
>Produksjon
Black>
Vi kan se at overordnet klassereferanse alltid vil referere til datamedlemmet til overordnet klasse.
B. Virtuell funksjon
EN virtuell funksjon er en medlemsfunksjon som er deklarert i basisklassen ved hjelp av nøkkelordet virtual og redefinert (Overstyrt) i den avledede klassen.
sammenligne med java
Noen nøkkelpunkter om virtuelle funksjoner:
- Virtuelle funksjoner er dynamiske.
- De defineres ved å sette inn nøkkelordet virtuell inne i en grunnklasse og er alltid deklarert med en grunnklasse og overstyrt i en barneklasse
- En virtuell funksjon kalles under Runtime
Nedenfor er C++-programmet for å demonstrere virtuell funksjon:
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();> }> |
>
>Produksjon
Called virtual Base Class function Called GFG_Base print function>
Eksempel 2:
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->vis();> >return> 0;> }> |
>
definere datamaskin
>Produksjon
print derived class show base class>