‫Hallo en welkom.
‫In deze lezing gaan we de belangrijkste stappen begrijpen die betrokken zijn bij het compileren van C++-bestanden in
‫Unreal.
‫Laten we erin duiken en kijken hoe ze werken.
‫Dus het wordt binnenkort tijd dat we code van buitenaf gaan gebruiken, van andere bestanden, en we moeten
‫leren hoe dit werkt in C++.
‫Om dat te doen, moeten we een kleine omweg maken en in meer detail begrijpen
‫wat er aan de hand is wanneer we onze C++-code in binair compileren.
‫Dus hier zijn de compilatiestappen die worden gebruikt.
‫We beginnen met uw code, uw C++-bestanden, uw hoofd van bestanden, allemaal in verschillende tekstbestanden.
‫Deze worden ingevoerd in een tool genaamd de Unreal Handed Tool.
‫Nu is deze tool verantwoordelijk voor het nemen van alle onwerkelijke specifieke stukken syntaxis en deze gebruiken
‫om meer C++-code te genereren.
‫Laten we eens kijken naar enkele voorbeelden van waar we deze onwerkelijke specifieke syntaxis hebben, deze nieuwe
‫klasse in hoofdletters die een onwerkelijke specifieke syntaxis is, en dat geldt ook voor het Crypt Reader API-ding hier en het
‫gegenereerde lichaam daar.
‫En wat hier eigenlijk aan de hand is, is dat de onwerkelijke header-tool deze verschillende stukjes syntaxis in je code zal
‫zien en gaan, oké, ik moet mijn werk doen.
‫Ik moet daar naar binnen, ik moet een heleboel dingen toevoegen.
‫Het gaat je gegenereerde lichaam vervangen door een heleboel code die ons leven gemakkelijker maakt bij het gebruik
‫van Unreal.
‫Het doet ook dingen als de U-eigenschappen en U-functies.
‫Het voegt alle dingen toe die het nodig heeft, zodat het kan communiceren met de blauwdrukwereld.
‫Dat is dus de eerste stap.
‫Het zet al zijn onwerkelijke specifieke dingen om in echte C++.
‫Zodra we de daadwerkelijke C++ hebben, kunnen we deze in een standaard C++-compilatieproces invoeren, dat drie
‫stappen duurt.
‫De eerste is om de voorbewerkingsstap af te handelen, dus dit zal eigenlijk een van de C++-syntaxis raken en heeft eigenlijk alleen
‫betrekking op regels die met een hash beginnen.
‫Dus we hebben een paar van deze preprocessing-richtlijnen.
‫Deze worden afgehandeld door de preprocessor.
‫De volgende stap is wat we eigenlijk de compiler noemen.
‫Er is een code voor nodig en het zet het om in uitvoerbaar binair bestand, maar het voltooit de stap
‫niet helemaal omdat het het alleen doet op individuele C++, wat bekend staat als vertaaleenheden, in feite C++-bestanden.
‫Er is dus een C++-bestand voor nodig en het vertaalt dat afzonderlijk naar binair, elk afzonderlijk C++-bestand.
‫En dan is de derde stap de linker, die dat alles bij elkaar brengt en een uitvoerbaar bestand oplevert dat
‫we eigenlijk één uitvoerbaar bestand kunnen uitvoeren.
‫Laten we deze standaard compilatiestappen eens wat gedetailleerder bekijken met een voorbeeldbestand.
‫Dus stel je voor dat we een spel dot CP hadden en het is een heel, heel eenvoudig spel omdat het alleen één en één
‫bij elkaar optelt.
‫Maar om één en één bij elkaar op te tellen, moet hij een functie gebruiken die in een ander bestand in de wiskunde
‫twee is gedeclareerd.
‫H Dus de wiskunde verklaart advertentie, maar het definieert niet echt wat het doet.
‫Dus dat wordt gedaan in de stap van de wiskundige punt.
‫En je kunt zien dat het inderdaad een heel eenvoudige implementatie is.
‫Wat gebeurt er nu in de pre-processing stap?
‫Zoals ik al zei, het behandelt alle preprocessor-richtlijnen, die dingen zijn die met een hash
‫beginnen.
‫Dus de hash bevat wiskunde, wat in feite betekent dat je alles in Master H hierheen kopieert.
‫Dus wat het doet, is dat het deze twee bestanden nodig heeft en het combineert ze samen om een nieuw uitvoerbestand
‫te maken met de naam game dot I eigenlijk game om op te nemen en je kunt zien dat het is inbegrepen.
‫De definitie van masturbatie heeft de hash preprocessor-richtlijn vervangen.
‫Dus nu heeft game dot II een definitie voor de add-operatie en dan draaien we de preprocessor op math dot
‫CVP.
‫Maar omdat het geen preprocessor-richtlijnen heeft, wordt daar in principe niets veranderd.
‫De volgende stap is dat de compilatie waarschijnlijk de belangrijkste en meest
‫gecompliceerde stap is, want wat het doet, is dat C++ in elk afzonderlijk bestand wordt geconverteerd naar binair, maar het is niet
‫volledig binair omdat mijn spel bijvoorbeeld niet echt weet hoe te implementeren en het kent gewoon de vorm
‫van die add-functie.
‫Dat moet dus later ingevuld worden en dat wordt ingevuld door de linker.
‫Dus de link neemt het binaire bestand, maakt het aan voor het spel dot obj-bestand en het binaire bestand
‫dat is gemaakt voor het methodebestand en brengt ze samen om een spel dot xy te maken dat het binaire bestand
‫voor beide combineert en uiteindelijk een compleet uitvoerbaar bestand is dat we kan echt draaien omdat het de definitie heeft voor alles wat het
‫nodig heeft.
‫Waarom hebben we zo'n ingewikkeld proces?
‫Het idee hier is dat het onze compilatietijd versnelt.
‫Want als ik maar een ketting zou maken.
‫Om dot slaap te spelen.
‫Ik hoef eigenlijk niet het hele compilatieproces uit te voeren.
‫Het enige wat ik hoef te doen is de bits draaien met game dot CBP, dus ik zou de preprocessor alleen op de CP draaien.
‫Dan zou ik de compiler alleen op het spel naar I uitvoeren.
‫En dan kan ik het math dot obj-bestand van eerder hergebruiken.
‫Ik hoef het niet opnieuw te compileren, want daarin is niets veranderd.
‫Evenzo, als ik alleen de wiskundige punt CP verander, zou ik het spel niet opnieuw naar het OBJ-bestand hoeven te compileren, daarom
‫is dit een efficiënter proces en waarom doen we het in de eerste plaats.
‫Dus ik zou graag willen dat we een klein experiment doen en proberen uit te vinden waarom we een punt h invoegen
‫en haar punt CP-bestand verplaatsen?
‫Wat is de reden ervoor?
‫Waarom kunnen we het C++-bestand niet gewoon compileren zonder move dot h.
‫Dus het experiment dat we gaan doen, is dat we commentaar gaan geven op de hash include-regel.
‫Dus een dubbele slash gebruiken om een opmerking voor die regel te plaatsen, waardoor het in feite
‫wordt verwijderd door de preprocessor in plaats van dat de preprocessor het vervangt door de inhoud van het
‫bestand.
‫We gaan dan opnieuw compileren en ik zou graag willen dat je de foutmeldingen bekijkt die eruit komen en kijk
‫wat er staat om te zien of je kunt proberen te begrijpen waarvoor we deze verplaatsing opnemen.
‫Pauzeer de video en probeer het.
‫Oké.
‫Welkom terug.
‫Dus laten we een dubbele schuine streep naar voren plaatsen aan het begin van deze regel, waardoor deze in feite nietig
‫is.
‫En dan gaan we een controle alt f 11 doen en gaan we kijken naar de uitvoer van live codering.
‫Dus kijk, we hebben meteen wat fouten, heel, heel vroeg.
‫En wat het zegt is dat je verhuizer geen klasse of naamruimte is en er zijn nog wat andere dingen hier
‫beneden.
‫Het zegt dat de primaire technische component is verklaard dat super is in de klasse of dat de eigenaar van de
‫naamruimte een onbekende identifier is.
‫En eigenlijk wil dit zeggen dat je het hier over je verhuizer hebt gehad, maar je hebt het toch
‫niet gedefinieerd, je hebt het nergens aangegeven.
‫Dus ik weet het niet.
‫De C++ compiler zegt, ik weet niet wat dit is.
‫Dus daarom zijn we hash inclusief de mover dot h omdat move it of H de class declareert.
‫Het zegt dat een U-mover een klasse is en dat het voortkomt uit je act een component en het heeft deze methoden, enz.
‫verklaart wat het betekent om die klasse te zijn.
‫Dus zonder die verklaring kan de C++-compiler niet doorgaan en daarom moeten we dat headerbestand
‫opnemen.
‫Goed spul.
‫Dus hopelijk begrijp je nu een beetje beter het proces dat betrokken is bij het compileren van C++ en in het
‫bijzonder het compileren van C++ in Unreal.
‫Ik zie je in de volgende lezing.