Polymorfisme en virtuele functies

Polymorfisme stelt ons in staat objecten van verschillende afgeleide klassen te behandelen via een pointer of verwijzing naar hun basisklasse, waardoor de juiste versie van een methode wordt aangeroepen tijdens runtime (Late Binding).

Virtuele functies: virtual en override

Om polymorfisme op een methode mogelijk te maken, moeten we deze declareren met het sleutelwoord virtual in de basisklasse. In afgeleide klassen gebruiken we de override specificatie om expliciet aan te geven dat we die methode overschrijven.

class Employee {
public:
    virtual void work() {
        std::cout << "Generic work" << std::endl;
    }
    // IMPORTANT: Virtual destructor in base class to avoid memory leaks
    virtual ~Employee() = default;
};

class Developer : public Employee {
public:
    void work() override {
        std::cout << "Writing C++ code" << std::endl;
    }
};

Met behulp van verwijzingen naar de basisklasse zal C++ de juiste methode tijdens runtime oplossen:

Employee* emp = new Developer();
emp->work(); // Prints "Writing C++ code" instead of "Generic work"
delete emp;

Abstracte klassen en pure virtuele functies

Een puur virtuele functie is een virtuele lidfunctie die aan het einde wordt gedeclareerd met = 0. Het vertegenwoordigt een formeel contract: de basisklasse biedt geen implementatie en delegeert deze volledig aan subklassen.

Een klasse die ten minste één puur virtuele functie bevat, wordt een Abstracte klasse genoemd en kan niet rechtstreeks worden geïnstantieerd.

class Instrument {
public:
    virtual void play() = 0; // Pure virtual
    virtual ~Instrument() = default;
};

class Piano : public Instrument {
public:
    void play() override {
        std::cout << "Playing piano..." << std::endl;
    }
};

Probeer het zelf