Cursusinhoud
C++ OOP
C++ OOP
Pure Virtuele Methode
Het concept van virtuele methoden is essentieel voor het bereiken van polymorfisme, waardoor flexibele en uitbreidbare softwareontwerpen mogelijk zijn. Pure virtuele methoden breiden dit uit door interfaces te definiëren en dynamische binding te ondersteunen.
Syntaxis van pure virtuele methode
Een pure virtuele methode wordt gedeclareerd met het sleutelwoord virtual en geïnitialiseerd op nul. Dit geeft aan dat de functie geen definitie heeft binnen de class en moet worden overschreven door elke subklasse voordat objecten van die class kunnen worden geïnstantieerd.
virtual.h
virtual void example() = 0;
Deze methode werkt vergelijkbaar met een standaardmethode, behalve dat deze geen body heeft tussen { } en in plaats daarvan wordt afgesloten met = 0;, wat aangeeft dat er geen implementatie is. De overige regels voor deze methode zijn echter hetzelfde als voor reguliere methoden.
Het declareren van een pure virtuele methode maakt de class waarin deze is gedeclareerd abstract, wat betekent dat het onmogelijk wordt om objecten van die klasse te instantieren. Deze beperking bestaat omdat elke methode binnen de class geïmplementeerd moet zijn voordat een instantie kan worden gemaakt en gebruikt, om fouten en onvoorspelbaar gedrag te voorkomen. Bekijk de onderstaande code:
Animal.h
class Animal { public: virtual void speak() = 0; };
De Animal-class bevat een pure virtuele methode genaamd speak(), waardoor het niet mogelijk is om objecten van deze klasse te instantieren. Dit ontwerp is logisch, aangezien het doel van de virtuele methode is om de karakteristieke geluiden van elk dier weer te geven.
Door de methode virtueel te maken, kan elke subklasse zijn eigen versie implementeren, waarmee de individualiteit van het geluid van elk dier wordt vastgelegd. Het als puur virtueel declareren geeft aan dat er geen standaardimplementatie bestaat, waarmee het belang van concrete implementaties in afgeleide klassen wordt benadrukt.
main.cpp
#include "Animal.h" int main() { // cannot declare variable 'animal' to be of abstract type Animal animal; }
Dit is eveneens logisch. Het aanmaken van instanties van de Animal-class zou onpraktisch en contra-intuïtief zijn, aangezien het een abstract concept vertegenwoordigt dat dient als categorie voor verschillende dieren. Er is geen specifiek gedrag gekoppeld aan een generiek dier, wat het abstracte karakter van de class onderstreept en het belang benadrukt van het creëren van gespecialiseerde subklassen om de unieke geluiden van elk specifiek dier vast te leggen.
main.cpp
#include <iostream> class Animal { public: // Pure virtual function to enforce implementation in derived classes virtual void speak() = 0; }; class Cat : public Animal { public: void speak() override { std::cout << "Meow!" << std::endl; } }; class Dog : public Animal { public: void speak() override { std::cout << "Bark!" << std::endl; } }; class Cow : public Animal { public: void speak() override { std::cout << "Moo!" << std::endl; } }; void pet(Animal& animal) { animal.speak(); } int main() { // Replace `Cat` with `Dog` or `Cow` to see their specific behavior Cat cat; pet(cat); }
Hoewel het niet mogelijk is om direct een object van het type Animal te maken, kunnen we het nog steeds als parameter in een functie gebruiken. Net als bij het eerdere knopvoorbeeld maakt deze aanpak gebruik van polymorfisme om een veelzijdig programma te creëren dat zijn gedrag dynamisch kan aanpassen tijdens de uitvoering.
Probeer een object van een andere class aan de functie door te geven en observeer de uitvoer. Probeer ook een object van de abstracte class te maken om te zien hoe de compiler het aanmaken verhindert vanwege niet-geïmplementeerde pure virtuele methoden.
Bedankt voor je feedback!
