‫Dus we weten dat we een aantal componenten nodig hebben op onze basis -- klasse.
‫We weten dat we een basisgaas nodig hebben voor het onderste deel van de tank en de toren.
‫We hebben ook een torentjegaas nodig voor het bovenste gedeelte.
‫We hebben een capsule nodig om botsingen aan te kunnen en we hebben een spawnpunt voor projectielen nodig.
‫Dat wordt een scènecomponent.
‫Nu, als we deze dingen eenmaal hebben toegevoegd aan de basis pod-klasse, dan zal alles wat we maken op basis
‫van deze klasse die dingen erven.
‫Dus we kunnen een tank maken op basis van de basis -- en dan kunnen we ook een toren maken op basis van de
‫basis --.
‫En omdat ze gebaseerd zijn op de basispod, erven ze deze componenten.
‫De tank kan zijn eigen basisgaas, zijn eigen torentje-gaas, zijn eigen capsule en zijn eigen projectiel-spawnpunt hebben.
‫En evenzo krijgt de toren zijn eigen basisgaas-turret-maascapsule-component en
‫projectiel-spawn-punt.
‫En we zullen heel snel zien hoe we verschillende meshes aan elk van deze kunnen toewijzen, zodat ze er anders uitzien.
‫We weten dus dat we een aantal componenten nodig hebben.
‫Nu is het tijd om wat componenten aan onze basisklasse toe te voegen.
‫Nu hebben we standaard al een openbare sectie, een beveiligde sectie en de tweede openbare sectie
‫hier beneden.
‫Er zijn verschillende redenen om meerdere openbare secties te hebben en daar zullen we het later over hebben.
‫Maar voor onze componenten gaan we een privégedeelte maken.
‫Zoals je eerder hebt geleerd, is het goed om lidvariabelen privé te hebben, zodat ze alleen
‫toegankelijk zijn vanuit de klasse die ze bezit.
‫We hebben dus een aantal componenten nodig.
‫De eerste die ik ga toevoegen is de capsule.
‫Laten we dus een variabele maken van het type capsulecomponent.
‫Dit wordt nu een aanwijzing.
‫We gaan pointers gebruiken voor de meeste van onze variabelen, zolang het geen basistypes zijn
‫zoals integer of float.
‫En zoals u weet, is dat omdat pointers licht van gewicht zijn, het zijn slechts adressen en ze stellen ons in
‫staat efficiënter te zijn.
‫Dus we hebben deze U-capsulecomponentaanwijzer en we gaan deze capsule-comp een afkorting noemen voor
‫capsulecomponent.
‫Nu, net boven de capsulecomponent, gaan we een onwerkelijke motorspecifieke macro toevoegen en het is jouw eigendom
‫in hoofdletters met zijn eigen haakjes.
‫Je eigendom is een manier om onwerkelijke engine bewust te maken van deze variabele, zodat deze kan deelnemen aan onwerkelijke
‫engines.
‫Reflectie systeem.
‫Het reflectiesysteem stelt ons in staat om dingen te doen zoals deze variabele bloot te stellen aan blauwdrukken en deel te
‫nemen aan het verzamelen van afval en dergelijke.
‫Dus het toevoegen van de you-eigenschap zal iets zijn dat aan onze componenten zal worden toegevoegd terwijl we ze maken.
‫Dus we hebben deze capsulecomponent en omdat we het YOU-capsulecomponenttype gebruiken, moeten we de compiler
‫op de hoogte stellen van dit type.
‫Het weet standaard niet wat een capsulecomponent is.
‫Om de compiler te vertellen wat een capsulecomponent is, zouden we normaal gesproken een headerbestand hier bovenaan opnemen
‫met onze include-richtlijnen als we naar de onwerkelijke motordocumentatie gaan en naar je capsulecomponent
‫zoeken, we kunnen hier zien waar het zegt neem het headerbestand op dat we zouden
‫moeten opnemen om de compiler over de capsulecomponent te vertellen.
‫Nu zouden we dit hier bovenaan kunnen opnemen en dan onze U.
‫Het type capsulecomponent zou door de compiler worden herkend en alles zou geweldig zijn.
‫Maar over het algemeen is het een goede gewoonte om deze dingen te coderen door te proberen dit headerbestand
‫zo klein mogelijk te houden.
‫Telkens wanneer we een headerbestand in dit bestand opnemen, neemt een programma genaamd de preprocessor alle inhoud
‫van dat headerbestand, verwijdert enkele dingen zoals opmerkingen en plakt dan letterlijk alle
‫inhoud van dat headerbestand in dit bestand.
‫Het resultaat is dat dit bestand groter wordt omdat het de inhoud heeft van dat opgenomen bestand en het hier
‫in plakt.
‫We willen alleen dingen opnemen als we ze gebruiken.
‫Dus hoe komen we weg met het niet opnemen van het header-bestand hier in de basis -- header?
‫Welnu, we kunnen iets in C++ gebruiken dat bekend staat als forward-declaratie.
‫We declareren dit u-capsule-componenttype door het class-sleutelwoord als volgt te gebruiken.
‫Merk op dat de compiler dit type nu groen toont wanneer we een variabele forward declareren en vervolgens
‫wegkomen zonder het headerbestand op te nemen.
‫Het vertelt de compiler dat dit een type is, zodat het ons geen IntelliSense-fouten meer geeft, en zegt dat
‫het dit niet als een type herkent.
‫Dit is nu een onvolledig type.
‫Als we dit type daadwerkelijk proberen te gebruiken, hetzij door toegang te krijgen tot leden zoals functies en variabelen, of door te proberen een
‫object van dit type te construeren, krijgen we een foutmelding omdat het een onvolledig type is.
‫We zouden het headerbestand nodig hebben waar we dit type gebruiken om die dingen te doen, zodat we een aanwijzer van een type
‫kunnen declareren om te voorkomen dat we het headerbestand nodig hebben.
‫Maar het is belangrijk op te merken dat we header-bestanden nodig hebben om van bepaalde klassen te erven.
‫Merk op dat deze klasse erft van een vijver en dat het vijverkopbestand hier bovenaan is opgenomen.
‫Dus overerving vereist het headerbestand voor het type waarvan we erven.
‫Dus laten we het hebben over voorwaartse declaratie en waarom we het willen doen.
‫Laten we zeggen dat we een klasse hebben met de naam Base Pon die een aanwijzervariabele van het type capsulecomponent
‫moet hebben.
‫Nu bevindt uw capsulecomponent zich in het headerbestand van de capsulecomponent.
‫Nu gaan we dit type gebruiken op basis van wanneer we een object van de U construeren.
‫Type capsulecomponent.
‫Dus in, gebaseerd op alles wat we echt nodig hebben, is een aanwijzer van het type U-capsulecomponent.
‫Nu is de waarheid gebaseerd op H heeft de implementatiedetails van de capsulecomponentklasse niet echt
‫nodig.
‫Met andere woorden, het hoeft niet te weten hoe de functies zijn gedefinieerd of zelfs hoe groot
‫de capsulecomponentklasse is.
‫Een capsulecomponentaanwijzer heeft dezelfde grootte als elke andere aanwijzer.
‫Het is maar een adres.
‫Nu in de basisplanklasse.
‫We willen de capsulecomponent construeren.
‫Om deze reden moeten we de grootte van een capsulecomponent weten om het geheugen in te delen dat nodig is om
‫dit object te maken.
‫Dus hoewel de kop van de capsulecomponent niet strikt nodig is in de basis Ponca, is het absoluut nodig in de basis.
‫Porkpie Dus een goede programmeerpraktijk is om alleen headers op te nemen waar je ze echt nodig hebt, zodat we weg kunnen komen
‫met het declareren van een aanwijzer van het type U capsulecomponentaanwijzer in basisproduct H en vervolgens capsulecomponenten op te nemen
‫waar we de implementatiedetails nodig hebben omdat we aan het construeren zijn een capsulecomponent en we moeten de
‫grootte van a weten.
‫Capsulecomponent in het geheugen.
‫Laten we nu de gevolgen bespreken van het opnemen van het headerbestand in base pond FX.
‫Zoals we hebben gezien, kunnen we dit absoluut doen en je denkt misschien, nou, we nemen het op in
‫base pont CP Hoe dan ook, dus wat maakt het uit als we het in het ene bestand opnemen versus het andere?
‫Hier komt het probleem om de hoek kijken.
‫Headerbestanden zijn ontworpen om door andere bestanden te worden opgenomen.
‫Dus laten we zeggen dat we Base Pond H hebben en daarin capsulecomponenten hebben opgenomen.
‫Verderop hebben we een andere klasse en we hebben een basisvijveraanwijzer in een andere
‫klasse, net zoals we een capsulecomponentaanwijzer in de basispod hadden.
‫Nu, in plaats van de moeite te nemen om de basispion en een andere klasse
‫naar voren te verklaren, gaan we het gewoon als normaal verklaren en de basispion in een andere klasse opnemen.
‫Dus nu bevat Base Pond H niet alleen de kop van de capsulecomponent, waardoor er meer code naar
‫dat kopbestand wordt gekopieerd.
‫Nu heeft een andere klasse een basis, waaronder een capsulecomponent.
‫Dus alle inhoud en capsulecomponenten vallen ook binnen een andere klasse H en het is daar niet
‫eens nodig.
‫Een andere klasse die H alleen over base hoeft te weten, geeft niet om de capsulecomponent.
‫Stel nu dat we dit patroon voortzetten en een andere klasse maken die nog een andere klasse wordt genoemd en dat nog
‫een andere klasse nu misschien een aanwijzer van het type een andere klasse nodig heeft in plaats van voorwaarts declareren.
‫We nemen gewoon een andere klasse H op in weer een andere klasse H en nu in weer een andere klasse H.
‫Ook al hebben we de header voor base pond of capsule component H niet eens nodig, we hebben hem
‫in nog een andere klasse omdat een andere klasse die header-bestanden erin bevat.
‫Dus we hebben kopieën van alle inhoud van capsulecomponenten en gebaseerd op H zit hier gewoon in weer een
‫andere klasse, dat bestand opblazen en de compileertijden verhogen, allemaal omdat we declaratie niet hebben doorgestuurd.
‫Dus in plaats daarvan is het beter om header-bestanden op te nemen waar ze echt nodig zijn.
‫Dus als we capsulecomponenten nemen en deze alleen opnemen op basis van CPP, en later wanneer we
‫een andere klasse maken en daadwerkelijk de basispod moeten gebruiken, kunnen we de koptekst
‫daar opnemen en base op bevat geen capsulecomponenten, dus al die extra code is niet inbegrepen in een andere
‫klasse.
‫En als we dan nog een klasse gaan maken die een andere klasse nodig heeft, kunnen we een andere
‫klasse die h opnemen in nog een andere klasse die CPP waar het echt nodig is en dan nog een andere
‫klasse die H niet gevuld raakt met de inhoud van andere header-bestanden die het niet nodig heeft.
‫Dus wanneer klassen afhankelijkheden hebben zoals deze, gebaseerd op de capsulecomponent, is het het beste om die afhankelijkheden tot
‫een minimum te beperken.
‫Dus ik ga je uitdagen om een compilatiefout te maken.
‫We moeten niet bang zijn voor compilatiefouten.
‫Ze zijn gewoon een normaal onderdeel van het ontwikkelingsproces.
‫Dus we gaan er een genereren die opzettelijk teruggaat en het class-sleutelwoord verwijdert en compileert zonder capsule comp
‫naar voren te declareren.
‫Als ik zeg compileren, bedoel ik dat je kunt compileren vanuit Visual Studio-code, gewoon een gewone C++-compilatie.
‫U hebt geleerd hoe u dat moet doen, of u kunt eenvoudig uw bestand en Visual Studio-code opslaan en
‫live codering starten.
‫Een van beide is prima en als we dit samen doornemen, zal ik je laten zien wat er met beide methoden
‫gebeurt.
‫Als je live codering gebruikt, kijk je natuurlijk naar de gegenereerde uitvoer in het live
‫coderingsvenster in tegenstelling tot de uitvoer die je zou zien in Visual Studio-code.
‫Nu spoiler, je krijgt een compilatiefout, kijk naar de compilatiefoutmelding, kijk wat het
‫je vertelt.
‫Dit is slechts om ons vertrouwd te maken met de fouten die we genereren.
‫Ga hierna heen en weer, declareer capsule comp met het class-sleutelwoord.
‫Als je dat eenmaal hebt gedaan, compileer dan opnieuw, deze keer zou je een succesvolle compilatie moeten krijgen.
‫Pauzeer de video en probeer dit eens.
‫Oké, dus laten we hier wat schade aanrichten aan onze code.
‫Ik ga het trefwoord klasse verwijderen.
‫Oké, dus we hebben geprobeerd te compileren, en hier is de uitvoer in de terminal.
‫Het eerste wat we zien is een fout en het geeft ons een foutcode en er staat dat capsule comp geen
‫lid is van een basispion.
‫We hebben een briefje waarop staat C declaratie van een basispion en dan zien we dat we hierdoor andere
‫fouten krijgen.
‫Dus vaak raken studenten in de war wanneer ze proberen te compileren en lijken ze meerdere fouten te maken.
‫Dit toont dus aan dat een enkele fout een reeks fouten kan verspreiden.
‫En dat betekent niet dat je een hele hoop bestanden moet gaan repareren.
‫De fout kan hier een enkele oorsprong hebben.
‫We weten wat de oorzaak van de fout is.
‫We moeten declaratie doorsturen.
‫Laten we nu eens kijken wat er gebeurt als we live codering gebruiken in plaats van gewone compilatie en Visual Studio-code.
‫Dus ik ga door en klik op de knop om live codering te starten en meteen in het rood zie ik dat
‫de build is mislukt en we zien hier hetzelfde.
‫Hier.
‫Capsule comp is geen lid van een basispion.
‫Zie de verklaring van een basispion.
‫Hier zien we dus hetzelfde.
‫Dus in beide gevallen krijgen we een fout als deze te zien als we vergeten declareren door te sturen.
‫Dus nu weten we hoe het eruit ziet en nu zijn we beter geïnformeerd en minder bang voor deze
‫mysterieuze compilatie-foutmeldingen.
‫Dus wat we gaan doen, is deze fout oplossen door je capsulecomponent door te geven, en dan kunnen
‫we proberen opnieuw te compileren.
‫En nu hebben we gecompileerd zonder fouten.
‫Dus nu zien we hoe het eruit ziet als we vergeten zijn om een variabele vooruit te declareren.
‫Houd daar rekening mee als u in de toekomst compilerfouten krijgt.
‫Dus kort samengevat, we hebben de forward declaratie besproken bij het maken van een nieuwe pointer en we hebben
‫geleerd dat je alleen moet opnemen wat je gebruikt in het CP-bestand en dat we zo weinig mogelijk in het H-bestand moeten
‫opnemen.
‫We weten dat we het headerbestand niet nodig hebben om een nieuwe pointer te declareren zolang we forward declareren en dat
‫we het headerbestand wel nodig hebben als we een object van een bepaald type gaan construeren.
‫En we hebben het headerbestand nodig om toegang te krijgen tot leden zoals functies en variabelen en we zagen dat we
‫het headerbestand echt nodig hebben voor overerving voor het erven van een klasse.
‫We hebben dat header-bestand daar nodig.
‫Dus nu we weten hoe we een type moeten declareren en we onze pointer capsule comp hebben, zijn we klaar
‫om daadwerkelijk een capsulecomponent-object te construeren en dat zullen we in de volgende video doen.
‫Ik zie je snel.