C++ Polymorfisme Uitgelegd: Praktische Voorbeelden & Kernconcepten

Wat is Polymorfisme in C++?

In C++ zorgt polymorfisme ervoor dat een member‑functie zich anders gedraagt, gebaseerd op het object dat het aanroept. Polymorfisme is een Griekse term die "vele vormen hebben" betekent. Het treedt op wanneer je een hiërarchie van klassen hebt die gerelateerd zijn via inheritance.

Bijvoorbeeld, stel we hebben de functie makeSound(). Als een kat deze functie aanroept, produceert het een miauw‑geluid. Als een koe dezelfde functie aanroept, produceert het een moe‑geluid.

Hoewel we één functie hebben, gedraagt deze zich anders onder verschillende omstandigheden. De functie heeft veel vormen; dus hebben we polymorfisme bereikt.

In deze C++ tutorial leer je:

• Wat is Polymorfisme?
• Typen Polymorfisme
• Compile‑Time Polymorfisme
• Function Overloading
• Operator Overloading
• Runtime Polymorfisme
• Function Overriding
• C++ Virtual Function
• Compile‑Time vs. Run‑Time Polymorfisme

Typen Polymorfisme

C++ ondersteunt twee typen polymorfisme:

• Compile‑time polymorfisme, en
• Runtime polymorfisme.

Compile‑Time Polymorfisme

Je roept overloaded functies aan door het aantal en type argumenten te matchen. De informatie is aanwezig tijdens compile‑tijd. Dit betekent dat de C++‑compiler de juiste functie tijdens compile‑tijd selecteert.

Compile‑time polymorfisme wordt bereikt via function overloading en operator overloading.

Function Overloading

Function overloading treedt op wanneer we veel functies met gelijkaardige namen maar verschillende argumenten hebben. De argumenten kunnen verschillen in aantal of type.

Voorbeeld 1:

 #include <iostream>
using namespace std;
void test(int i) {
    cout << " The int is " << i << endl;
}
void test(double f) {
    cout << " The float is " << f << endl;
}
void test(char const *ch) {
    cout << " The char* is " << ch << endl;
}
int main() {
    test(5);
    test(5.5);
    test("five");
    return 0;
 } 

Output:

Hier is een screenshot van de code:

Code‑uitleg:

1. Include iostream header voor functies.
2. Include std naamruimte voor klassen zonder prefix.
3. Creëer functie test met integer parameter i.
4. Statement voor uitvoering bij aanroep.
5. Einde functie body.
6. Creëer functie test met float parameter f.
7. Statement voor uitvoering bij aanroep.
8. Einde functie body.
9. Creëer functie test met character parameter ch.
10. Statement voor uitvoering bij aanroep.
11. Einde functie body.
12. Roep main() aan.
13. Roep test aan met 5 – roept integer‑versie aan.
14. Roep test aan met 5.5 – roept float‑versie aan.
15. Roep test aan met "five" – roept char*‑versie aan.
16. Programma retourneert waarde bij succes.
17. Einde main().

We hebben drie functies met dezelfde naam maar verschillende argument‑typen. We hebben polymorfisme bereikt.

Operator Overloading

Bij Operator Overloading definiëren we een nieuwe betekenis voor een C++ operator. Het verandert ook hoe de operator werkt. Bijvoorbeeld, we kunnen de + operator definiëren om twee strings te concateneren. We kennen het als opteloperator voor numerieke waarden. Na onze definitie, wanneer tussen integers geplaatst, voegt het ze toe. Wanneer tussen strings geplaatst, concateneert het ze.

Voorbeeld 2:

 #include<iostream>
using namespace std;
class ComplexNum {
private:
    int real, over;
public:
    ComplexNum(int rl = 0, int ov = 0) {
        real = rl;
        over = ov;
    }
    ComplexNum operator + (ComplexNum const &obj) {
        ComplexNum result;
        result.real = real + obj.real;
        result.over = over + obj.over;
        return result;
    }
    void print() {
        cout << real << " + i" << over << endl;
    }
};
int main() {
    ComplexNum c1(10, 2), c2(3, 7);
    ComplexNum c3 = c1+c2;
    c3.print();
 } 

Output:

Hier is een screenshot van de code:

Code‑uitleg:

1. Include iostream header.
2. Include std naamruimte.
3. Creëer klasse ComplexNum.
4. Gebruik private voor variabelen.
5. Definieer real en over als integers.
6. Gebruik public voor constructor.
7. Creëer constructor en initialiseer variabelen.
8. Initialiseer real.
9. Initialiseer over.
10. Einde constructor body.
11. We moeten de betekenis van + overschrijven.
12. Creëer datatype result van type ComplexNum.
13. Gebruik + met complexe getallen – reële delen optellen.
14. Gebruik + met complexe getallen – imaginaire delen optellen.
15. Retourneer result bij succes.
16. Einde definitie nieuwe betekenis +.
17. Roep print() aan.
18. Print nieuw complex getal na optelling.
19. Einde print() functie.
20. Einde ComplexNum class.
21. Roep main() aan.
22. Geef waarden voor reële en complexe delen door. Eerste deel c1 + eerste deel c2 = 10+3. Tweede deel c1 + tweede deel c2 = 2+7.
23. Voer operatie uit met overloaded + en sla op in c3.
24. Print waarde van c3.
25. Einde main().

Runtime Polymorfisme

Dit gebeurt wanneer een object‑methode tijdens runtime aangeroepen wordt in plaats van tijdens compile‑tijd. Runtime polymorfisme wordt bereikt via function overriding. De aan te roepen functie wordt tijdens runtime vastgelegd.

Function Overriding

Function overriding treedt op wanneer een functie van de base‑class een nieuwe definitie krijgt in een derived‑class. Op dat moment zeggen we dat de base‑functie geöverschreven is.

Bijvoorbeeld:

 #include <iostream>
using namespace std;
class Mammal {
public:
    void eat() {
        cout << "Mammals eat...";
    }
};
class Cow: public Mammal {
public:
    void eat() {
        cout << "Cows eat grass...";
    }
};
int main(void) {
    Cow c = Cow();
    c.eat();
    return 0;
 } 

Output:

Hier is een screenshot van de code:

Code‑uitleg:

1. Importeer iostream header.
2. Include std naamruimte.
3. Creëer klasse Mammal.
4. Gebruik public voor de functie.
5. Creëer publieke functie eat.
6. Print statement bij aanroep eat().
7. Einde eat() body.
8. Einde Mammal class.
9. Creëer klasse Cow die Mammal erft. Cow is derived, Mammal is base.
10. Gebruik public voor functie.
11. Overschrijf eat() uit base‑class.
12. Statement om te printen bij aanroep.
13. Einde eat() body.
14. Einde Cow class.
15. Roep main() aan.
16. Creëer instantie Cow met naam c.
17. Roep eat() aan gedefinieerd in Cow.
18. Programma retourneert waarde bij succes.
19. Einde main().

C++ Virtual Function

Een virtual function is een andere manier om run‑time polymorfisme in C++ te implementeren. Het is een speciale functie gedefinieerd in een base‑class en hergedefinieerd in de derived‑class. Om een virtual function te declareren, gebruik je het virtual-keyword. Het keyword moet de declaratie van de functie in de base‑class voorafgaan.

Als een virtual function class geërfd wordt, herdefinieert de derived‑class de virtual function passend bij zijn behoeften. Bijvoorbeeld:

 #include <iostream>
using namespace std;
class ClassA {
public:
    virtual void show() {
        cout << "The show() function in base class invoked..." << endl;
    }
};
class ClassB :public ClassA {
public:
    void show() {
        cout << "The show() function in derived class invoked...";
    }
};
int main() {
    ClassA* a;
    ClassB b;
    a = &b;
    a->show();
 } 

Output:

Hier is een screenshot van de code:

Code‑uitleg:

1. Include iostream header.
2. Include std naamruimte.
3. Creëer klasse ClassA.
4. Gebruik public voor class member.
5. Creëer virtual functie show(). Publieke functie.
6. Tekst om te printen bij aanroep show(). endl = einde regel.
7. Einde show() body.
8. Einde ClassA body.
9. Creëer nieuwe klasse ClassB die ClassA erft. ClassA = base, ClassB = derived.
10. Gebruik public voor class member.
11. Herdefinieer virtual functie show() uit base‑class.
12. Tekst om te printen bij aanroep show() in derived class.
13. Einde show() body.
14. Einde ClassB body.
15. Roep main() aan.
16. Creëer pointer variabele a die wijst naar ClassA.
17. Creëer instantie ClassB met naam b.
18. Wijs adres van b toe aan a.
19. Roep show() aan gedefinieerd in derived class. Late binding geïmplementeerd.
20. Einde main().

Compile‑Time Polymorfisme vs. Run‑Time Polymorfisme

Hier zijn de belangrijkste verschillen:

Samenvatting:

• Polymorfisme betekent vele vormen hebben.
• Het treedt op wanneer er een hiërarchie van klassen is gerelateerd via inheritance.
• Met polymorfisme kan een functie zich anders gedragen gebaseerd op het object dat het aanroept.
• Bij compile‑time polymorfisme wordt de aan te roepen functie tijdens compile‑tijd vastgelegd.
• Bij runtime polymorfisme wordt de aan te roepen functie tijdens runtime vastgelegd.
• Compile‑time polymorfisme wordt bepaald door function overloading en operator overloading.
• Bij function overloading zijn er veel functies met gelijke namen maar verschillende argumenten.
• Parameters kunnen verschillen in aantal of type.
• Bij operator overloading wordt een nieuwe betekenis gedefinieerd voor C++ operators.
• Runtime polymorfisme wordt bereikt via function overriding.
• Bij function overriding geeft een derived‑class een nieuwe definitie aan een functie gedefinieerd in de base‑class.