Antwoord.

Geschiedenis van de vraag:

Polymorfisme is een van de kernkenmerken van object-georiënteerd programmeren sinds de vroege ontwikkeling van C++. Het doel is om objecten via een basisinterface aan te spreken, zonder je zorgen te maken over het specifieke type. Dit vergroot de expressiviteit en flexibiliteit van de code aanzienlijk.

Probleem:

Zonder polymorfisme wordt de code inflexibel: je moet expliciet de types van objecten achterhalen, switch/case gebruiken, en handmatige typecasting toepassen. Dit bemoeilijkt het onderhoud en de uitbreidbaarheid van de applicatie — het toevoegen van nieuwe types wordt kostbaar of onmogelijk zonder bestaande code te wijzigen.

Oplossing:

In C++ wordt polymorfisme bereikt door het gebruik van virtuele functies. Klassen verklaren virtuele methoden, en afgeleiden klassen implementeren deze. De basis klasse biedt een gemeenschappelijke interface, terwijl de werkelijke acties afhankelijk zijn van het werkelijke type van het object waarop de pointer of referentie verwijst.

Voorbeeldcode:

#include <iostream>

class Animal {
public:
    virtual void speak() const { std::cout << "Een bepaald diergeluid
"; }
    virtual ~Animal() {}
};

class Dog : public Animal {
public:
    void speak() const override { std::cout << "Woef!
"; }
};

void makeSound(const Animal& a) {
    a.speak();
}

int main() {
    Dog dog;
    makeSound(dog); // Output: Woef!
}

Kernkenmerken:

• Virtuele functies moeten worden verklaard met het sleutelwoord virtual in de basis klasse.
• Gebruik voor veiligheid een virtuele destructor in een polymorf hiërarchie.
• Gebruik override voor expliciete overriding — dit verhoogt de veiligheid van de code.

Misleidende vragen.

Wat gebeurt er als de destructor van de basis klasse niet virtueel is?

Het verwijderen van een object via een pointer naar de basis klasse zal alleen de destructor van de basis klasse aanroepen, en de destructor van de afgeleide klasse zal niet worden aangeroepen, wat leidt tot resource leaks.

Voorbeeldcode:

class Base { public: ~Base() { /*...*/ } };
class Derived : public Base { public: ~Derived() { /*...*/ } };
Base* obj = new Derived();
delete obj; // UB: Derived::~Derived wordt niet aangeroepen

Is het mogelijk om alleen gedeeltelijk virtuele methoden te verklaren, terwijl de destructor niet virtueel blijft?

Nee, als een klasse polymorf is (er is ten minste één virtuele functie), moet de destructor virtueel zijn om geheugen- of resource leaks te vermijden.

Werken virtuele functies voor members die als static zijn verklaard?

Nee, statische members van een klasse kunnen niet virtueel zijn, omdat ze niet tot een specifiek object behoren, en er bestaat geen mechanisme voor dynamische binding voor hen.

Typische fouten en anti-patronen

• Ontbreken van een virtuele destructor in een hiërarchie met virtuele methoden.
• Vergeten om de override marker toe te voegen in de afgeleide klasse, wat leidt tot onjuiste overriding van de method.
• Aanroepen van virtuele functies vanuit constructors/destructors, wanneer dynamische binding niet moet plaatsvinden.

Voorbeeld uit het leven

Negatief geval

Een zeer grote hiërarchie van apparaatklassen, waarbij elke afgeleide klasse zijn eigen resource beheert (bijvoorbeeld een geopend bestand), maar de destructor van de basis klasse is niet virtueel. Bij verwijdering via een pointer naar de basis worden de resources niet vrijgegeven.

Voordelen: Project wordt snel opgebouwd, minimaal aantal virtuele aanroepen.

Nadelen: Geheugenlekken, verkeerde vernietiging. Zeer moeilijk te onderhouden en uit te breiden.

Positief geval

Een doordachte polymorfe hiërarchie, waarbij de basis klasse virtuele functies en een virtuele destructor heeft. Het sleutelwoord override en RAII-principes worden toegepast.

Voordelen: Veilige omgang met resources, eenvoudige uitbreiding, testbaarheid.

Nadelen: Iets lagere prestaties door vtable-lookup, vaccin tegen "over-engineering" als overerving wordt toegepast zonder noodzaak.