‫Dus in deze lezing gaan we het hebben over de virtuele methode in C++.
‫We hebben het eerder gezien, we hebben het gebruikt, maar hebben we het volledig begrepen?
‫Laat ons zien.
‫Dus het idee van een virtuele methode is dat het ons in staat stelt om functies in een basisklasse te overschrijven.
‫We hebben dit gezien met dingen als beginnen, spelen en opnemen in Unreal.
‫Maar laten we hier verder op ingaan en begrijpen waarom ze als virtueel zijn gemarkeerd.
‫Het stelt ons in staat om de functionaliteit in die basisklasse te veranderen, en het doet iets dat Dynamic Dispatch wordt genoemd, waar
‫we het zo meteen over zullen hebben om te begrijpen wat dit echt betekent en waarom virtuele
‫methoden niet de standaardfunctionaliteit zijn in C++ zoals ze zijn in veel andere talen, zoals C Sharp.
‫Dus laten we hier eens naar kijken.
‫Ik ga dit doen op de CPP dot S-H website zodat we hier helemaal niet in Unreal zijn.
‫We kijken alleen naar de onbewerkte C++-functionaliteit, zodat u deze taalfunctie kunt begrijpen en hoe deze
‫werkt.
‫Nu, het eerste dat ik hier ga doen, is gewoon doorgaan en de hoofdmethode opruimen.
‫En in onze use case gaan we nadenken over een klasse voor wapens, aangezien dit een veel voorkomende use case is
‫voor games.
‫Dus laten we een klasse bekijken, het geweer vrij eenvoudig koelen en dan zullen we het
‫lichaam van deze klasse openbaar maken en een void shoot-methode.
‫En ik ga gewoon door en verklaar de inhoud van deze schietmethode hier in de rij om de dingen supereenvoudig
‫te houden.
‫Trouwens, je kunt dit doen als je dit nog niet eerder hebt gezien.
‫Maar over het algemeen willen we dingen in een apart C++-bestand doen om dingen gescheiden te houden, de compilatietijden
‫sneller te maken enzovoort.
‫Maar hier, waar het slechts een speelgoedvoorbeeld is, is dit prima.
‫Dus we gaan een SD uitkijken.
‫Dus C++ gebruiken als output string stuff en we gaan knallen.
‫Kortom, wanneer we deze methode aanroepen en dan gaan we naar de eindregel.
‫En dat is de kern van onze parachutemethode.
‫En we kunnen de klas afsluiten met de accolade en de puntkomma.
‫Dus laten we doorgaan en deze klasse daadwerkelijk gebruiken.
‫Ik ga een my gun-variabele in het algemeen maken en ik ga mijn gun dot shoot noemen en laten we kijken of alles
‫hier werkt zoals het hoort.
‫Druk op de run-knop en knal.
‫Het roept de methode aan zoals we zouden verwachten.
‫Wat gebeurt er als ik mijn geweer wil verlengen en misschien een geweer of pistool wil maken dat een pistool wordt genoemd.
‫Dus klasse pistool is een geërfd van pistool, dat zo zou doen.
‫En als je dit nog niet eerder hebt gezien, omdat je dit waarschijnlijk niet eerder hebt
‫geschreven, doe je een openbare erfenis van wapens zodat andere klassen kunnen zien dat je van wapen erft.
‫En dan doen we in het openbare gedeelte, we willen misschien onze eigen schietmethode maken voor het pistool dat
‫deze functionaliteit overschrijft.
‫En in plaats van de knal aan het einde hier te printen, willen we pil printen omdat het een kleiner pistool is,
‫het maakt een kleiner geluid en dat is onze schietmethode daar.
‫En laten we de klas daar afsluiten.
‫En wat we willen doen is een pistool voor onszelf maken.
‫Dus schiet mijn pistool hier op de hoofdmethode.
‫En omdat deze hier gewoon bestaan, precies op de hoofdmethode, gebruiken we geen verwijzingen naar hen.
‫Daarom gebruiken we hier de puntoperator in plaats van de pijl.
‫Dus de mijn pistool dot shoot.
‫Laten we eens kijken wat dat doet.
‫Ik verwacht dat het ppu zal printen, wat het ook doet.
‫Stoer.
‫Oké, dus laten we onze methoden die bellen verwijderen.
‫Schiet er direct op en laten we eens kijken hoe de dingen zich zouden gedragen met een aanwijzer.
‫Dus ik ga een pistoolwijzer maken met de naam pistool.
‫Pieter.
‫En op de volgende regel zou ik het op dezelfde regel kunnen doen, maar omwille van de eenvoud, ik ga het op de volgende
‫regel doen.
‫Ik ga die pistoolaanwijzer zo instellen dat deze wijst naar het adres van het adres van de operator, het
‫adres van de my gun-variabele.
‫En omdat het een aanwijzer is, moeten we de pijloperator gebruiken om de schietmethode aan te roepen.
‫Dus ik ga schieten op mijn geweer roepen.
‫Laten we op uitvoeren klikken en we krijgen knal als resultaat daar.
‫Stoer.
‫Wat gebeurt er als ik hetzelfde doe?
‫Maar in plaats van het pistool op mijn pistool te richten, zette ik het op mijn pistool.
‫Laten we doorgaan en nu rennen.
‫Oké.
‫Dat is een interessant gedrag daar.
‫Wat hier aan de hand is, is dat deze eerste methode in beide gevallen wordt aangeroepen.
‫Dus waarom is deze tweede shoot-methode niet genoemd?
‫We hebben hier een pistool als aanwijzer.
‫Welnu, wat er gebeurt als je geen virtuele methode hebt, is dat C++ standaard het type van je
‫aanwijzer gebruikt, wat een pistoolwijzer is.
‫Onthoud dat het dat type zal gebruiken om de methode te vinden die moet worden aangeroepen.
‫Dus het zal deze schietmethode bovenaan gaan noemen in plaats van de overschreven methode in het pistool.
‫Om de overschreven methode in het pistool aan te roepen, zou het moeten bellen.
‫Het zou een wijzer van het type pistool moeten hebben.
‫Dat is prima.
‫En je kunt zien waarom ze dit doen.
‫Het is voor efficiëntie.
‫Bij C++ draait alles om efficiëntie.
‫Als iets meer gaat kosten wanneer het wordt gecompileerd, wanneer het wordt uitgevoerd, dan zal C++ het standaard niet doen, tenzij
‫je erom vraagt.
‫Dus het is heel gemakkelijk voor C++ om het op te zoeken en te gaan. Wel, dit is een pistoolwijzer, dus
‫ik noem deze pistoolwijzermethode.
‫En dit is waar Dynamic Dispatch om de hoek komt kijken.
‫Deze mooie term betekent in feite dat we niet willen dat het dat doet.
‫Wat we willen dat het doet, is zeggen, wacht even, wat is er eigenlijk opgeslagen in die pistoolwijzer?
‫Wat is daar het echte type?
‫En het echte type dat we ons realiseren is dat het een type pistool is.
‫En dus moeten we ons afvragen, is er een methode voor dat type die overschreven wordt?
‫En ja, die is er.
‫Dus hoe geven we C++ de toestemming om net dat beetje minder efficiënt te zijn en geven we ons de
‫mogelijkheid om te overschrijven zonder dat aanwijzertype te hoeven veranderen, wat niet altijd per se mogelijk is.
‫In veel gevallen is het zelfs niet mogelijk, zoals het geval is wanneer je je eigen aangepaste actieve klasse
‫hebt.
‫Unreal heeft de aanwijzer niet ingesteld om naar uw specifieke klasse te verwijzen, waardoor ze de hele engine moeten
‫veranderen telkens wanneer u een nieuwe klasse introduceert.
‫Nee, dat kan gewoon niet.
‫Ze hebben een verwijzing naar iets van het type act om in de hoofdrol te spelen.
‫Dus toen ze begin play aanroepen, wilde je je Begin Play-methode aanroepen.
‫Het moet dus virtueel zijn.
‫En dat is de sleutel hier.
‫Als we virtueel voor de methode in de bovenliggende klasse blijven, geeft dit nu een signaal aan C ++ dat een seconde blijft
‫hangen, als ik shoot op een aanwijzer van het type gun pointer aanroep, moet ik controleren of dit bijvoorbeeld niet het geval
‫is , een pistool en dat deze schietmethode is opgeheven.
‫Dus als we doorgaan en nu rennen, kun je zien dat we knallen en dan pue.
‫Dus het werkt zoals we zouden verwachten met dynamische verzending.
‫En dat is de term voor dit ding, waar we eigenlijk gewoon bedoelen, controleren wat voor soort type dit echt in
‫de aanwijzer wordt vastgehouden en de relevante methode aanroepen.
‫Nu is er een extra klein beetje syntaxis dat u ons vaak zult zien gebruiken, en dat is
‫het override-sleutelwoord.
‫En dat zet je achter een methode die je probeert te overschrijven als virtueel.
‫En eigenlijk is het override-sleutelwoord niet strikt noodzakelijk, en evenmin is virtueel opnieuw plaatsen tegen iets in
‫de kinderklasse van een pistool.
‫Je hoeft dus niet virtueel te zetten, maar het kan geen kwaad om het te doen.
‫Maar overschrijven is vooral handig omdat het ons in staat stelt om ervoor te zorgen dat onze naam correct
‫is.
‫Dus als ik op uitvoeren druk, loopt alles zoals voorheen wanneer ik override heb.
‫Maar stel dat ik per ongeluk de naam van deze methode verkeerd had, dus ik doe de override niet.
‫En ik had het bijvoorbeeld een note shooter genoemd.
‫Ik heb de naam verkeerd gekopieerd.
‫Ik typte het in in plaats van het te kopiëren.
‫Als ik nu op rennen druk, zie je, we hebben weer dezelfde fout omdat we proberen af te koelen om te schieten.
‫We hebben het per abuis ten onrechte overschreven.
‫Het gaat knal, knal.
‫Dus de manier waarop ik dit kan vermijden is door te zeggen: Nou, ik probeer iets te negeren.
‫Dus ik heb mijn override-sleutelwoord hier geplaatst, en als ik het nu probeer te compileren, kun je zien dat er staat dat
‫shooter is gemarkeerd als override, maar er is geen methode, geen virtuele methode die ik kan overschrijven, in welk geval ik
‫kan gaan , Oh ja, dat heb ik verkeerd getypt.
‫Dus ik ga door en corrigeer mijn code en ga gewoon terug om te schieten.
‫En nu werkt het zoals ik het bedoeld had.
‫Het is dus net dat beetje extra veiligheid door die override daar te plaatsen en meteen dit.
‫Zou ons ook beschermen tegen het geval dat het ding dat we proberen te negeren niet virtueel is.
‫Als ik dat probeer te doen, kun je zien dat het zegt dat het is gemarkeerd als overschrijven,
‫maar het overschrijft niet omdat die bovenliggende klasse geen virtuele functie voor schieten heeft.
‫Dus hopelijk geeft dit je een beetje een overzicht van hoe C++ virtuele functies gebruikt en implementeert en waarom
‫we er zo expliciet over moeten zijn.
‫Laten we nu eens nadenken over wat meer gebruiksscenario's voor virtuele functies in het algemeen.
‫We hebben al wat van de motor gezien.
‫Waar heb je virtual gebruikt eerder gezien?
‫Waar kun je je voorstellen dat je het gebruikt?
‫We hebben zojuist een use case-voorbeeld gezien waarbij je een pistool en verschillende overrides daarvan hebt
‫die op verschillende manieren schieten.
‫Hoe kun je je anders voorstellen dat je virtuele functies gebruikt om de functionaliteit in bovenliggende klassen te overschrijven?
‫Als je een antwoord op die twee vragen hebt bedacht, volg dan de link naar de
‫discussies in deze lezing en post je antwoord.
‫Ze de use-cases en de plaatsen waar je ze eerder hebt gebruikt en zien wat andere mensen hebben bedacht.
‫Misschien helpt dat je om je begrip van virtuele methoden te verstevigen.
‫Dat was het voor deze lezing.
‫Ik zie je in de volgende waar we in woede virtuele methoden zullen gebruiken.