C ++ polymorfism

I denna handledning lär vi oss om polymorfism i C ++ med hjälp av exempel.

Polymorfism är ett viktigt begrepp för objektorienterad programmering. Det betyder helt enkelt mer än en form. Det vill säga samma enhet (funktion eller operatör) beter sig olika i olika scenarier. Till exempel,

Den +operatör i C ++ används för att utföra två specifika funktioner. När den används med siffror (heltal och flytande siffror) utför den addition.

 int a = 5; int b = 6; int sum = a + b; // sum = 11

Och när vi använder +operatören med strängar utför den strängsammankoppling. Till exempel,

 string firstName = "abc "; string lastName = "xyz"; // name = "abc xyz" string name = firstName + lastName;

Vi kan implementera polymorfism i C ++ på följande sätt:

  1. Funktionsöverbelastning
  2. Överbelastning av operatören
  3. Överstyrande funktion
  4. Virtuella funktioner

C ++ - funktion överbelastning

I C ++ kan vi använda två funktioner med samma namn om de har olika parametrar (antingen typer eller antal argument).

Och beroende på antalet / typen av argument anropas olika funktioner. Till exempel,

 // C++ program to overload sum() function #include using namespace std; // Function with 2 int parameters int sum(int num1, int num2) ( return num1 + num2; ) // Function with 2 double parameters double sum(double num1, double num2) ( return num1 + num2; ) // Function with 3 int parameters int sum(int num1, int num2, int num3) ( return num1 + num2 + num3; ) int main() ( // Call function with 2 int parameters cout << "Sum 1 = " << sum(5, 6) << endl; // Call function with 2 double parameters cout << "Sum 2 = " << sum(5.5, 6.6) << endl; // Call function with 3 int parameters cout << "Sum 3 = " << sum(5, 6, 7) << endl; return 0; )

Produktion

 Summa 1 = 11 Summa 2 = 12.1 Summa 3 = 18

Här har vi skapat 3 olika sum()funktioner med olika parametrar (antal / typ av parametrar). Och baserat på argumenten som skickats under ett funktionsanrop kallas en viss sum().

Det är en sammanställningstidspolymorfism eftersom kompilatorn vet vilken funktion som ska utföras innan programmet kompileras.

För att lära dig mer om det, besök vår C ++ -funktionsöverbelastningshandledning.

C ++ överbelastning av operatören

I C ++ kan vi överbelasta en operatör så länge vi arbetar på användardefinierade typer som objekt eller strukturer.

Vi kan inte använda föraren överbelastning för grundtyper såsom int, doubleetc.

Operatörsöverbelastning är i grunden funktionsöverbelastning, där olika operatörsfunktioner har samma symbol men olika operander.

Och beroende på operander utförs olika operatörsfunktioner. Till exempel,

 // C++ program to overload ++ when used as prefix #include using namespace std; class Count ( private: int value; public: // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix void operator ++() ( value = value + 1; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1; // Call the "void operator ++()" function ++count1; count1.display(); return 0; )

Produktion

 Räkna: 6

Här har vi överbelastat ++operatören, som arbetar på objekt av Countklass (objekt count1 i det här fallet).

Vi har använt den här överbelastade operatören för att direkt öka värdevariabeln för count1-objektet med 1.

Detta är också en sammanställningstidspolymorfism .

För att lära dig mer, besök vår C ++ - handledning för överbelastning av operatörer.

C ++ - funktion åsidosättande

I C ++ arv kan vi ha samma funktion i basklassen såväl som dess härledda klasser.

När vi kallar funktionen med hjälp av ett objekt från den härledda klassen, utförs funktionen för den härledda klassen istället för den i basklassen.

Så olika funktioner utförs beroende på objektet som anropar funktionen.

Detta är känt som funktionen åsidosättande i C ++. Till exempel,

 // C++ program to demonstrate function overriding #include using namespace std; class Base ( public: virtual void print() ( cout << "Base Function" << endl; ) ); class Derived : public Base ( public: void print() ( cout << "Derived Function" << endl; ) ); int main() ( Derived derived1; // Call print() function of Derived class derived1.print(); return 0; )

Produktion

 Deriverad funktion

Här har vi använt en print()funktion i Baseklassen och samma funktion i Derivedklassen

När vi ringer print()med Derivedobjektet härledd1 åsidosätter det print()funktionen Basegenom att utföra print()funktionen i Derivedklassen.

Det är en runtime-polymorfism eftersom funktionsanropet inte löses av kompilatorn, men det löses i runtime istället.

För att lära dig mer, besök vår C ++ -funktionsöverskridande handledning.

C ++ virtuella funktioner

I C ++ kanske vi inte kan åsidosätta funktioner om vi använder en pekare i basklassen för att peka på ett objekt från den härledda klassen.

Användning av virtuella funktioner i basklassen säkerställer att funktionen kan åsidosättas i dessa fall.

Således faller virtuella funktioner faktiskt under funktionsstyrning . Till exempel,

 // C++ program to demonstrate the use of virtual functions #include using namespace std; class Base ( public: virtual void print() ( cout << "Base Function" << endl; ) ); class Derived : public Base ( public: void print() ( cout << "Derived Function"

Output

 Derived Function

Here, we have used a virtual function print() in the Base class to ensure that it is overridden by the function in the Derived class.

Virtual functions are runtime polymorphism.

To learn more, visit our C++ Virtual Functions tutorial.

Why Polymorphism?

Polymorphism allows us to create consistent code. For example,

Suppose we need to calculate the area of a circle and a square. To do so, we can create a Shape class and derive two classes Circle and Square from it.

In this case, it makes sense to create a function having the same name calculateArea() in both the derived classes rather than creating functions with different names, thus making our code more consistent.

Intressanta artiklar...