Ordet polymorfism betyder att ha många former. I enkla ord kan vi definiera polymorfism som förmågan hos ett meddelande att visas i mer än en form. Ett verkligt exempel på polymorfism är en person som samtidigt kan ha olika egenskaper. En man är samtidigt en far, en man och en anställd. Så samma person uppvisar olika beteende i olika situationer. Detta kallas polymorfism. Polymorfism anses vara en av de viktiga egenskaperna hos objektorienterad programmering.
Typer av polymorfism
- Kompileringstidspolymorfism
- Runtime polymorfism
Typer av polymorfism
1. Kompileringstidspolymorfism
Denna typ av polymorfism uppnås genom funktionsöverbelastning eller operatörsöverbelastning.
A. Funktionsöverbelastning
När det finns flera funktioner med samma namn men olika parametrar, sägs funktionerna vara det överbelastad, därför är detta känt som funktionsöverbelastning. Funktioner kan överbelastas av ändra antalet argument eller och ändra typen av argument . Enkelt uttryckt är det en egenskap hos objektorienterad programmering som ger många funktioner som har samma namn men distinkta parametrar när många uppgifter listas under ett funktionsnamn. Det finns vissa regler för funktionsöverbelastning som bör följas när en funktion överbelastas.
Nedan är C++-programmet för att visa funktionsöverbelastning eller kompileringstidspolymorfism:
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;> }> |
>
upcasting
>Produktion
value of x is 7 value of x is 9.132 value of x and y is 85, 64>
Förklaring: I exemplet ovan kallas en enda funktion funktion func() agerar olika i tre olika situationer, vilket är en egenskap hos polymorfism. För att veta mer om detta kan du hänvisa till artikeln – Funktion Överbelastning i C++ .
B. Operatörsöverbelastning
C++ har förmågan att ge operatörerna en speciell betydelse för en datatyp, denna förmåga är känd som operatörsöverbelastning. Till exempel kan vi använda additionsoperatorn (+) för strängklass för att sammanfoga två strängar. Vi vet att denna operatörs uppgift är att lägga till två operander. Så en enda operator '+', när den placeras mellan heltalsoperander, lägger till dem och när den placeras mellan strängoperander sammanfogar de dem.
Nedan är C++-programmet för att demonstrera operatörens överbelastning:
CPP
sortera arraylistan i 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();> }> |
>
>Produktion
12 + i9>
Förklaring: I exemplet ovan är operatorn '+' överbelastad. Vanligtvis används denna operator för att addera två tal (heltal eller flyttal), men här görs operatorn att utföra addition av två imaginära eller komplexa tal. För att veta mer om denna, se artikeln - Operatör överbelastning .
2. Runtime Polymorphism
Denna typ av polymorfism uppnås genom Funktion Åsidosättande . Sen bindning och dynamisk polymorfism är andra namn för runtime polymorfism. Funktionsanropet löses vid körning in runtime polymorfism . Däremot, med kompileringstidspolymorfism, bestämmer kompilatorn vilket funktionsanrop som ska bindas till objektet efter att ha härlett det vid körning.
A. Åsidosättande av funktioner
Funktion Åsidosättande inträffar när en härledd klass har en definition för en av medlemsfunktionerna i basklassen. Den basfunktionen sägs vara åsidosatt.
Funktionsöverordnad Förklaring
Runtime Polymorphism med datamedlemmar
Runtime Polymorphism kan inte uppnås av datamedlemmar i C++. Låt oss se ett exempel där vi får åtkomst till fältet genom referensvariabel för överordnad klass som refererar till instansen av den härledda 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;> }> |
java arv
>
handledning för javafx
>Produktion
Black>
Vi kan se att föräldraklassreferensen alltid kommer att referera till datamedlemmen i förälderklassen.
B. Virtuell funktion
A virtuell funktion är en medlemsfunktion som deklareras i basklassen med hjälp av nyckelordet virtual och omdefinieras (Overridden) i den härledda klassen.
Några nyckelpunkter om virtuella funktioner:
- Virtuella funktioner är dynamiska till sin natur.
- De definieras genom att infoga nyckelordet virtuell inuti en basklass och deklareras alltid med en basklass och åsidosätts i en barnklass
- En virtuell funktion anropas under Runtime
Nedan är C++-programmet för att demonstrera virtuell funktion:
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();> }> |
>
>Produktion
Called virtual Base Class function Called GFG_Base print function>
Exempel 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->visa();> >return> 0;> }> |
gräns med css
>
>Produktion
print derived class show base class>