‫Hallo en welkom.
‫In deze lezing gaan we iets leren over een vreemd fenomeen dat een buitenste parameter wordt genoemd.
‫Dit is een parameter die in plaats van de waarde in C++ door te geven, we de neiging hebben om de waarde uit een functie door
‫te geven.
‫En we gaan ook zien over iets dat een constante referentie wordt genoemd en hoe deze
‫twee concepten met elkaar verweven zijn.
‫Laten we erin duiken en dit uitzoeken.
‫Nutsvoorzieningen.
‫De echte plaats waar verwijzingen naar schijnen is in parameters naar functies, want elke keer
‫dat we een float-delta-tijd zoals deze in onze component maken, nemen we een kopie van die originele float
‫en geven deze door aan de functie.
‫Dus in plaats van dat te doen, willen we er misschien een verwijzing naar nemen en dat doorgeven.
‫Dus laten we ons voorstellen dat we een functie zouden creëren in grab it, elk genaamd print damage.
‫En als argument voor deze functie willen we een float-schade doorgeven.
‫Dit gaat, zoals ik al zei, een kopie maken van alles wat we doorgeven en het naar die variabele kopiëren.
‫Maak deze parametervariabele in de functie voor afdrukschade.
‫En we moeten hier ook een geretourneerde waarde van void hebben om het te voltooien en een puntkomma aan het einde.
‫Laten we naar de C++ gaan en dit gesprek voortzetten.
‫Laten we hier de afdrukschade maken.
‫Zet de you grab een class ervoor en laten we wat accolades plaatsen in plaats van de puntkomma.
‫Dus we hebben een kopie in de variabele schadeparameter en het is veilig, want als ik schade zou
‫doen gelijk aan vijf, verander ik deze variabele hier alleen binnen printschade.
‫Ik heb er zelf een kopie van.
‫Ik kan het niet per ongeluk verpesten.
‫Wat als ik geen kopie wil maken?
‫Mijn alternatief zou zijn om een referentie te nemen.
‫Dus wat ik hier kan doen, is dat ik een float-referentie in drukschade kan plaatsen, en ik
‫moet die ook bijwerken in het C ++ -bestand.
‫En dan heb ik misschien dit logbericht dat we de referentie gebruiken voor laten we gaan en
‫dit opschrijven en in drukschade zetten.
‫Dus nu nemen we onze schade en we printen het outlet-updates, de logboekverklaringen zeggen: schade is dit geval van
‫schade, is dit schade.
‫En wat we in onze tick-component kunnen doen, is dat we schade kunnen afdrukken en de schadevariabele kunnen doorgeven en een puntkomma aan het
‫einde kunnen plaatsen.
‫En we kunnen onze schadereferentie voorlopig wegwerken, want wat we nu aan de hand hebben is een beschadigde vlotter
‫die in tech is gemaakt.
‫Het geheugen hiervoor is hier in take aangemaakt en dan gaan we het aan deze print damage functie geven.
‫Maar omdat de parameter een referentie is, kopiëren we deze schade niet echt.
‫We nemen het adres en slaan dat op in de referentie, zodat wanneer we deze referentie
‫verder gebruiken, we feitelijk toegang hebben tot het originele stuk geheugen.
‫Er hoefde dus geen kopie te gebeuren om de schade af te drukken.
‫Laten we nu eens kijken of dit echt doet wat we ervan verwachten.
‫Als ik de schadewaarde verander in bijvoorbeeld vijf en dan opnieuw compileer en op play druk, ga dan eens kijken naar
‫het uitvoerlogboek en de afdruk dat de schade vijf is.
‫Maar omdat we een referentie hebben, weten we dat we die waarde kunnen bijwerken.
‫Dus wat ik kan doen is dat ik binnen deze functie zou kunnen zeggen dat ik zou kunnen doen, hey, schade zou gelijk moeten zijn aan
‫twee zoals zo.
‫En als ik niet voorzichtig was, als ik dacht dat ik mijn eigen exemplaar had, zou ik misschien denken dat dat oké is.
‫Maar eigenlijk hebben we in de tick-component de oorspronkelijke A-variabelen gewijzigd.
‫Als ik hier een kleine log in doe om die originele schadevariabele te inspecteren en we zetten een procent F en geven
‫de schade hier door, laten we coderen en dat compileren en we gaan op play drukken.
‫Kijk eens in onze output log en je kunt zien dat nu de schade en de originele schade
‫beide zijn aangepast.
‫Ze zijn allebei veranderd in de nummer twee, wat niet geweldig is.
‫Weet je, je zou per ongeluk veel schade kunnen aanrichten, als je de woordspeling wilt excuseren, door variabelen te veranderen waarvan
‫je niet had verwacht dat ze zouden veranderen.
‫En hier komt nog een gebruik van dat const-sleutelwoord dat we in het verleden hebben gezien.
‫Als ik const voor mijn float-referentie plak, dan zeg ik hier dat dit een referentie moet zijn
‫die je niet kunt veranderen.
‫Je kunt er geen contactloze functies op aanroepen, je kunt hem niet instellen.
‫U kunt de inhoud van deze variabele op geen enkele manier wijzigen.
‫Je kunt het alleen gebruiken, je kunt het alleen lezen, je kunt alleen zien wat erin staat.
‫Dus als we teruggaan naar ik pak een kopie, we moeten ervoor zorgen dat we Const hier ook in
‫de parameters plaatsen en we kunnen doorgaan en compileren en je ziet dat we een build-fout krijgen en de fout
‫zegt dat schade niet kan worden toegewezen omdat het een constante variabele is.
‫Dus dat geeft ons de bescherming die we nodig hebben.
‫Dus in het algemeen, als we proberen een variabele door te geven, op een efficiënte manier waar we geen kopie
‫willen maken, dan zullen we altijd, altijd het contact trefwoord gebruiken en ook een referentie
‫gebruiken, omdat dit ons verhindert om die inhoud per ongeluk wijzigen.
‫Nu wil je het echter soms gebruiken om die waarde te wijzigen.
‫En wat we als voorbeeld zouden kunnen hebben, we kunnen een Booleaanse retourwaarde hebben en we zouden kunnen zeggen dat er
‫schade is, maar we kunnen ook, zoals we in het verleden in Blueprint hebben gedaan, een tweede retourwaarde willen hebben.
‫Dus we zouden kunnen zeggen: hebben we schade en wat is die schade?
‫Welnu, in dit geval is het eigenlijk logisch om een eenvoudige contactloze referentie te gebruiken, een zwevende referentie.
‫De schade, en normaal gesproken zouden we dit eigenlijk schade noemen om het echt zichtbaar te maken
‫dat dit een zogenaamde out-parameter is.
‫Het is geen parameter om dingen door te geven.
‫Het is een parameter om dingen door te geven.
‫Nu kan het een beetje een rare gril van C++ zijn en het kan moeilijk te herkennen zijn.
‫Maar over het algemeen, als je parameters ziet die een referentie zijn maar niet
‫zijn gemarkeerd als contact, dan kun je vrijwel aannemen dat iemand die als een out-parameter wilde gebruiken.
‫Dus dat is wat we hier hebben.
‫We hebben schade.
‫En als we dit zouden gaan implementeren in de CPP, dan kunnen we de 'you grab a class' hier vooraan
‫zetten en we kunnen onze accolades hier tussen haakjes plaatsen.
‫We gaan commentaar geven op de regel afdrukschade waar het niet blij mee is, omdat we proberen
‫een contactreferentie in te stellen.
‫En wat we hier in wezen kunnen doen, is dat we wat code kunnen doen, we kunnen zien of we schade hebben
‫en dan zouden we afdrukken, ja, oké.
‫Out schade is gelijk aan vijf.
‫Dus dat is de schade die is aangericht en we kunnen terugkeren.
‫Dat is waar, want we hebben wat schade aangericht en dit kunnen we nu gebruiken in ergens als
‫TEC-componenten om de schade te pakken te krijgen.
‫Dus hier in plaats van de schade vijf in te stellen, kunnen we de schade krijgen en deze
‫afdrukken als er enige schade is, zodat we iets in deze trant kunnen zeggen als er schade is en dan geven we de variabele door
‫die we willen vullen met de schade .
‫Dus schade bijvoorbeeld, en dan kunnen wij de body van onze opgave hebben en zouden wij bijvoorbeeld alleen printschade kunnen
‫noemen, als er schade is te tonen en wij deze kunnen verwijderen, logt u geheel in.
‫Dit is dus de manier waarop we contactloze referenties gebruiken als out-parameters, een manier om meerdere retourwaarden uit
‫een functie te halen.
‫En typisch wanneer we dit doen, wanneer we deze functie aanroepen, zullen we de variabele creëren, maar we zullen
‫er geen initiële waarde aan geven.
‫Dus op regel 39 heb ik eigenlijk een vlotterschade gedefinieerd.
‫Ik geef het meteen door in de volgende regel.
‫En dit is een ander veelbetekenend teken dat u een out-parameter gebruikt.
‫Ik heb geen waarde gegeven voordat ik het in een functie heb doorgegeven, wat betekent dat ik verwacht
‫dat die functie de waarde voor mij invoert.
‫Dus dit kan in het begin moeilijk te herkennen zijn en het kan een beetje verwarrend zijn.
‫Maar dit zijn de twee regels waarvan ik wil dat je ze onthoudt.
‫Als je een variabele ziet die gedeclareerd is en geen waarde heeft gekregen en onmiddellijk wordt doorgegeven aan een functie, vraag jezelf dan af
‫of dat een out-parameter is.
‫En de andere regel is dat als je een referentie als parameter ziet, maar het is geen content, dat ook
‫een hint kan zijn dat dit een out-parameter is.
‫En natuurlijk, als de variabele of parameter ergens een naam heeft, dan is dat een dode weggeefactie dat dit
‫ding bedoeld is als een out-parameter.
‫Goed spul.
‫Ik denk dat dat ons heel goed heeft voorbereid om een sweep te kunnen doen.
‫Dus ik zie je in de volgende lezing.