C ++ polymorfisme

I denne vejledning lærer vi om polymorfisme i C ++ ved hjælp af eksempler.

Polymorfisme er et vigtigt begreb med objektorienteret programmering. Det betyder simpelthen mere end en form. Det vil sige, at den samme enhed (funktion eller operatør) opfører sig forskelligt i forskellige scenarier. For eksempel,

Den +operatør i C ++ anvendes til at udføre to specifikke funktioner. Når det bruges med tal (heltal og flydende tal), udfører det tilføjelse.

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

Og når vi bruger +operatøren med strenge, udfører den streng sammenkædning. 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åder:

  1. Funktion overbelastning
  2. Operatør overbelastning
  3. Overordnet funktion
  4. Virtuelle funktioner

C ++ Funktion Overbelastning

I C ++ kan vi bruge to funktioner med samme navn, hvis de har forskellige parametre (enten typer eller antal argumenter).

Og afhængigt af antallet / typen af ​​argumenter kaldes forskellige funktioner. 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; )

Produktion

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

Her har vi oprettet 3 forskellige sum()funktioner med forskellige parametre (antal / type parametre). Og baseret på de argumenter, der er sendt under et funktionsopkald, kaldes en bestemt sum().

Det er en kompileringstidspolymorfisme, fordi compileren ved, hvilken funktion der skal udføres, før programmet kompileres.

For at lære mere om det, besøg vores C ++ -funktionsoverbelastningsvejledning.

C ++ Operatør Overbelastning

I C ++ kan vi overbelaste en operatør, så længe vi arbejder på brugerdefinerede typer som objekter eller strukturer.

Vi kan ikke bruge operatør overbelastning for basale typer såsom int, doubleosv

Operatøroverbelastning er grundlæggende funktionsoverbelastning, hvor forskellige operatørfunktioner har det samme symbol, men forskellige operander.

Og afhængigt af operanderne udføres forskellige operatørfunktioner. 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; )

Produktion

 Tæl: 6

Her har vi overbelastet ++operatøren, der opererer på objekter af Countklasse (objektantal1 i dette tilfælde).

Vi har brugt denne overbelastede operatør til direkte at øge værdivariablen for count1 objekt med 1.

Dette er også en kompileringstidspolymorfisme .

Hvis du vil vide mere, kan du besøge vores C ++ -vejledning til operatøroverbelastning.

C ++ - funktion tilsidesat

I C ++ arv kan vi have den samme funktion i basisklassen såvel som dens afledte klasser.

Når vi kalder funktionen ved hjælp af et objekt fra den afledte klasse, udføres funktionen for den afledte klasse i stedet for den i basisklassen.

Så forskellige funktioner udføres afhængigt af objektet, der kalder funktionen.

Dette er kendt som funktionsoverstyring 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; )

Produktion

 Afledt funktion

Her har vi brugt en print()funktion i Baseklassen og den samme funktion i Derivedklassen

Når vi kalder print()bruge Derivedobjektet derived1, tilsidesætter den print()funktion Baseved at udføre print()funktionen af Derivedklassen.

Det er en runtime-polymorfisme, fordi funktionsopkaldet ikke løses af compileren, men det løses i runtime i stedet.

Hvis du vil vide mere, kan du besøge vores C ++ - Overstyring af funktion.

C ++ virtuelle funktioner

I C ++ er vi muligvis ikke i stand til at tilsidesætte funktioner, hvis vi bruger en markør i basisklassen til at pege på et objekt fra den afledte klasse.

Brug af virtuelle funktioner i baseklassen sikrer , at funktionen i disse tilfælde kan tilsidesættes.

Således falder virtuelle funktioner faktisk under funktionsoverstyring . 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...