C++ Virtual Functies

Deze tutorial legt C++ virtual functies uit, hun doel en praktisch gebruik geïllustreerd met codevoorbeelden.

Een virtual functie is een basisklasse-lid dat we verwachten dat afgeleide klassen zullen overriden. Het declareren van een functie als virtual zorgt ervoor dat de meest afgeleide implementatie wordt aangeroepen, zelfs wanneer benaderd via een basisklasse-pointer of referentie.

Wanneer een basisklasse een non-virtual lid bevat, zal het aanroepen van dat lid via een basispaltter altijd de basisversie uitvoeren, ongeacht het daadwerkelijke objecttype. Overweeg het volgende:

class Base { public: void print() { // basisimplementatie } }; class Derived : public Base { public: void print() { // afgeleide implementatie } }; 

In het onderstaande programma wijst een Base* naar een Derived instantie, toch lost print() op in de basisversie:

int main() { Derived derived1; Base* base1 = &derived1; base1->print(); // roept Base::print() aan return 0; } 

Om polymorf gedrag te bereiken, declareer de functie als virtual in de basisklasse:

class Base { public: virtual void print() { // basisimplementatie } }; 

Virtual functies zijn centraal voor C++ polymorfisme. Voor een diepere duik, zie onze C++ Polymorfisme gids.

Voorbeeld 1: Basis Virtual Functie Gebruik

#include <iostream> using namespace std; class Base { public: virtual void print() { cout << "Base Function" << endl; } }; class Derived : public Base { public: void print() override { cout << "Derived Function" << endl; } }; int main() { Derived derived1; Base* base1 = &derived1; base1->print(); // print Derived Function return 0; } 

Output

Derived Function

Omdat Base::print virtual is, dispatched de aanroep naar Derived::print zelfs via een basispaltter.

De C++ Override Identifier

Sinds C++11 helpt het override sleutelwoord onbedoelde mis-overriding te voorkomen door de compiler te dwingen te verifiëren dat een functie daadwerkelijk een virtual basisklasse-lid overridet.

Voorbeeld:

class Base { public: virtual void print() { // basisimplementatie } }; class Derived : public Base { public: void print() override { // afgeleide implementatie } }; 

Als je de overruling functie buiten de klasse definieert, gebruik:

class Derived : public Base { public: void print() override; // declaratie }; void Derived::print() { // implementatie } 

Veilig Gebruik van override

Zonder override resulteert een typfout of handtekening mismatch stilzwijgend in een nieuwe functie in plaats van een override, wat leidt zu subtiele bugs. De compiler zal dan een fout uitsturen, wat het probleem direct zichtbaar maakt. Veelvoorkomende vallen zijn:

• Namen mismatch: bv. pint() in plaats van print()
• Verschillende return types: bv. int retourneren in plaats van void
• Parameter mismatch: afwijkende parameterlijsten
• Ontbrekende virtual in basis: de basisfunctie is helemaal niet virtual

Praktisch Gebruik van Virtual Functies

Overweeg een Dier basisklasse met afgeleide Hond en Kat klassen. Elke klasse bevat een type lid geïnitialiseerd door zijn constructor.

class Dier { private: string type; public: Dier() : type("Dier") {} virtual string getType() const { return type; } }; class Hond : public Dier { private: string type; public: Hond() : type("Hond") {} string getType() const override { return type; } }; class Kat : public Dier { private: string type; public: Kat() : type("Kat") {} string getType() const override { return type; } }; 

Met getType() virtual, kan een enkele helper elk dier printen:

void print(Dier* dier) { cout << "Dier: " << dier->getType() << endl; } 

Gebruik in main():

int main() { Dier* dier1 = new Dier(); Dier* hond1 = new Hond(); Dier* kat1 = new Kat(); print(dier1); print(hond1); print(kat1); delete dier1; delete hond1; delete kat1; return 0; } 

Output

Dier: Dier Dier: Hond Dier: Kat

Door getType() virtual te maken, vermijden we duplicatie van print() logica in elke afgeleide klasse en zorgen we ervoor dat het juiste type wordt benaderd.