CKTIS / C++
Zuiver virtuele functie (= 0) in C++
Met `= 0` declareer je een zuiver virtuele lidfunctie. Daarmee definieer je een abstracte interface die verschillende implementaties kan aanroepen, afhankelijk van het type van het object.
Versie: ISO C++23; implementation support may vary
Syntax
struct Strategy {
virtual int apply(int x) const = 0;
virtual ~Strategy() = default;
};In virtual int apply(int x) const = 0; maakt = 0 de lidfunctie zuiver virtueel. Het is geen toekenning en ook geen retourwaarde. Een overschrijvende functie kan zelf ook zuiver virtueel zijn: int apply(int x) const override = 0;.
Een klasse is abstract als voor minstens één virtuele functie de uiteindelijke versie in die klasse nog zuiver virtueel is. Je kunt geen zelfstandig object van een abstracte klasse maken, maar een pointer of referentie van het basistype kan naar een concreet afgeleid object verwijzen. override helpt fouten op te sporen: zonder const overschrijft Half::apply de functie Strategy::apply niet.
Een zuiver virtuele functie kan buiten de klasse worden gedefinieerd en blijft dan zuiver virtueel. Een gekwalificeerde aanroep zoals strategy.Strategy::apply(12) omzeilt virtuele dispatch en vereist die definitie. Een directe of indirecte virtuele aanroep van een zuiver virtuele functie vanuit de constructor of destructor van een abstracte klasse, op het object dat wordt opgebouwd of afgebroken, heeft ongedefinieerd gedrag, zelfs als de functie is gedefinieerd.
De publieke destructor virtual ~Strategy() = default; gebruikt de standaarddefinitie en is niet zuiver virtueel. Hij zorgt voor de juiste vernietigingsvolgorde wanneer std::unique_ptr<Strategy> één object via Strategy* verwijdert. Zou de destructor met = 0 zuiver virtueel worden gedeclareerd, dan was bij het maken van afgeleide objecten nog steeds een definitie buiten de klasse nodig.
print krijgt een const Strategy& in plaats van zelf een strategie te maken. Dat is dependency injection: de virtuele aanroep van apply kiest de implementatie op basis van het werkelijke type van het object. Een factoryregister kan kiezen uit strategieën die in het programma zijn gecompileerd; virtuele dispatch laadt zelf geen gedeelde bibliotheken.
Voorbeelden
#include <iostream>
#include <memory>
struct Strategy {
virtual int apply(int x) const = 0;
virtual ~Strategy() = default;
};
struct Half : Strategy {
int apply(int x) const override { return x / 2; }
};
struct Third : Strategy {
int apply(int x) const override { return x / 3; }
};
void print(const Strategy& strategy) {
std::cout << strategy.apply(12) << '\n';
}
int main() {
std::unique_ptr<Strategy> half = std::make_unique<Half>();
std::unique_ptr<Strategy> third = std::make_unique<Third>();
print(*half);
print(*third);
}
Resultaat
6 4
`Half` deelt `12` door `2` en `Third` door `3`. Dezelfde functie `print` schrijft eerst `6` en daarna `4`.
Gerelateerde lessen
- C++ · Les 59 · Gevorderd · Versie: 3