C ++ polymorfisme

I denne opplæringen vil vi lære om polymorfisme i C ++ ved hjelp av eksempler.

Polymorfisme er et viktig begrep for objektorientert programmering. Det betyr ganske enkelt mer enn én form. Det vil si at den samme enheten (funksjon eller operatør) oppfører seg annerledes i forskjellige scenarier. For eksempel,

Den +operatør i C ++ blir brukt til å utføre to bestemte funksjoner. Når det brukes med tall (heltall og flytende tall), utfører det tillegg.

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

Og når vi bruker +operatøren med strenger, utfører den streng sammenkobling. For eksempel,

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

Vi kan implementere polymorfisme i C ++ på følgende måter:

  1. Funksjon overbelastning
  2. Overbelastning av operatør
  3. Overstyring av funksjonen
  4. Virtuelle funksjoner

C ++ Funksjon Overbelastning

I C ++ kan vi bruke to funksjoner med samme navn hvis de har forskjellige parametere (enten typer eller antall argumenter).

Og avhengig av antall / type argumenter, kalles forskjellige funksjoner. For eksempel,

 // 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; )

Produksjon

 Sum 1 = 11 Sum 2 = 12.1 Sum 3 = 18

Her har vi laget 3 forskjellige sum()funksjoner med forskjellige parametere (antall / type parametere). Og, basert på argumentene som ble sendt under en funksjonsanrop, kalles en bestemt sum().

Det er en kompileringstidspolymorfisme fordi kompilatoren vet hvilken funksjon som skal utføres før programmet kompileres.

For å lære mer om, besøk vår C ++ Funksjon Overbelastningsveiledning.

C ++ Overbelastning av operatør

I C ++ kan vi overbelaste en operatør så lenge vi opererer på brukerdefinerte typer som objekter eller strukturer.

Vi kan ikke bruke operatør overbelastning for grunnleggende typer som int, doubleetc.

Operatøroverbelastning er i utgangspunktet funksjonsoverbelastning, der forskjellige operatørfunksjoner har samme symbol, men forskjellige operander.

Avhengig av operandene, utføres forskjellige operatørfunksjoner. For eksempel,

 // 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; )

Produksjon

 Antall: 6

Her har vi overbelastet ++operatøren, som opererer på objekter av Countklasse (objektantall1 i dette tilfellet).

Vi har brukt denne overbelastede operatøren for å øke verdivariabelen til count1-objektet direkte med 1.

Dette er også en kompileringstidspolymorfisme .

For å lære mer, besøk vår C ++ Operator Overloading tutorial.

C ++ - funksjon overstyring

I C ++ arv kan vi ha samme funksjon i basisklassen så vel som dens avledede klasser.

Når vi kaller funksjonen ved hjelp av et objekt fra den avledede klassen, blir funksjonen til den avledede klassen utført i stedet for den i basisklassen.

Så forskjellige funksjoner utføres avhengig av objektet som kaller funksjonen.

Dette er kjent som funksjonsoverstyring i C ++. For eksempel,

 // 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; )

Produksjon

 Avledet funksjon

Her har vi brukt en print()funksjon i Baseklassen og den samme funksjonen i Derivedklassen

Når vi ringer print()ved hjelp av Derivedobjektet derivert1, overstyrer det print()funksjonen til Baseved å utføre print()funksjonen til Derivedklassen.

Det er en kjøretidspolymorfisme fordi funksjonsanropet ikke løses av kompilatoren, men det løses i løpet av tiden.

For å lære mer, besøk vår C ++ Funksjon Overriding tutorial.

C ++ virtuelle funksjoner

I C ++ kan vi kanskje ikke overstyre funksjoner hvis vi bruker en peker i baseklassen for å peke på et objekt fra den avledede klassen.

Bruk av virtuelle funksjoner i baseklassen sikrer at funksjonen kan overstyres i disse tilfellene.

Dermed faller virtuelle funksjoner faktisk under funksjonsoverstyring . For eksempel,

 // 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.

Interessante artikler...