Hallo, en welkom terug. In deze lezing wil ik een demonstratie
geven van onze vorige uitdaging, namelijk het
begrijpen van pass by reference,
waarbij een parameter in een functie een pointer krijgt.
Dus laten we een nieuw project maken. We noemen dit een
pointer pass by reference, want dat is wat
het demonstreert, basisdingen hier, nieuw project,
consoletoepassing c. Hier vrij eenvoudig.
Laten we deze aanwijzer onderstrepingsteken pass
by reference noemen.
Nogmaals, we laten zien hoe we parameters binnen een functie kunnen gebruiken om
gegevens door te geven en hoe die gegevens vervolgens buiten
de functie worden gewijzigd.
Dus het eerste dat we gaan doen, is dat we onze functiedeclaratie gaan
maken, ons functieprototype. Dit is altijd fijn om
te doen zodat je overal in je programma kunt bellen. We gaan het gewoon vierkant noemen.
Het belangrijkste in deze functiedeclaratie is dat er een pointer voor nodig is.
Er is dus gewoon een eindpunt nodig, dus we zeggen gewoon int star
en dan kun je het elke gewenste naam geven en het eindigen met een puntkomma.
En onze belangrijkste functie, eerst
gaan we doen, we gaan gewoon een normale integer-variabele maken
en we zeggen gewoon int num en we zeggen hard code het naar 9.
En wat we gaan doen, is dat we onze vierkantsfunctie gaan aanroepen.
Onze vierkante functie gaat geen gegevens retourneren, het wordt ongeldig.
We moeten er nu echter een adres aan doorgeven omdat onze vierkantsfunctie op regel 4 een aanwijzer aanneemt.
Dus we kunnen geen num doorgeven, we zouden het adres van num moeten invoeren, en dan
zouden we het eindigen met een puntkomma. Dus we roepen de functie aan
met behulp van de functienaam en geven vervolgens het adres van de variabele door.
Omdat de variabele hier in een regel acht geen pointer is.
Dan kunnen we gewoon de waarde van num afdrukken.
En nogmaals, wat je hier zult opvallen, is omdat we
het adres doorgeven, als we de gegevens in de functie zelf voor die
variabele veranderen, zal het daarbuiten veranderen. Dus hier gaan we zeggen
dat het kwadraat van het gegeven getal is en het is gewoon
procent d, we voegen een regelinvoer
toe en we gaan gewoon num afdrukken, en num wordt
niet 9. , dat zal ik je vertellen.
En dan retourneren we gewoon 0 voor onze normale functie.
Dus nu moeten we de functie daadwerkelijk implementeren, definiëren.
Om het te definiëren, zeg ik gewoon leeg vierkant.
We weten dat er een integer-pointer voor nodig is, dus ik zeg int star x.
En nu willen we het gewoon met zichzelf vermenigvuldigen.
Maar we willen er zeker van zijn dat we het adres niet veranderen.
Dus wat we hier zouden kunnen doen, is dat we dit een constante kunnen
maken, maar je zou de constante na het
gegevenstype willen plaatsen omdat we de waarde van wat x
is of het adres van waar het naar verwijst niet willen veranderen we zouden kunnen zeggen int constant.
Als we de waarde van x niet
willen veranderen, zouden we constant zeggen. Maar we willen de waarde van x veranderen, we gaan het zelf kwadrateren.
Dus om het op zichzelf te kwalificeren, allereerst, wat we willen
veranderen, is de uiteindelijke waarde van x. We moeten dus de
indirecte operator gebruiken. We moeten de verwijzing naar de asterisk verwijderen.
En dan gaan we gewoon gelijken zeggen, we willen niet
x keer x doen, want dat gaat alleen maar de adressen vermenigvuldigen. X is een aanwijzer, we willen niet alleen de
waarde van x krijgen, we willen de waarde krijgen van waar x naar wijst.
Dus nogmaals, we moeten het de-refereren en dan
gaan we het met zichzelf vermenigvuldigen. We gaan het twee keer de-refereren.
Misschien een goed idee om dit tussen
haakjes te zetten, zodat het heel gemakkelijk te begrijpen is wat hier aan de hand is.
Je de-referentie van de aanwijzer, de waarde ervan krijgen en dan vermenigvuldigen
met zijn waarde en dan voeg je gewoon de puntkomma toe, en dat
is alles wat je hoeft te doen. Dus als we dit programma uitvoeren, wordt
81 afgedrukt.
Het gaat de waarde van num afdrukken. Num gaat binnen vierkant veranderen omdat
we het adres daar doorgeven.
We kunnen de waarde van de aanwijzer niet echt veranderen, dus
we hebben de constante achter het type.
Dus hier zeggen we build en het lijkt erop dat
we de verklaring niet hebben gewijzigd.
En nu willen we er zeker van zijn dat
al het andere correct is.
Als u wilt dat de aanwijzer constant is, moet
u deze achter de asterisk zetten.
Dus int start constant betekent
dat je de waarde van x, het
adres van num, niet kunt veranderen.
Als we const vóór de int
of na de invoer vóór de asterisk plaatsen, betekent
dit dat u de waarde van waar de aanwijzer naar verwijst niet kunt wijzigen.
Dus als we dit nu uitvoeren, zouden we output 81 moeten zien.
Nogmaals, wat dit ons
vertelt, is dat we de gegevens hebben
gewijzigd. Deze variabele, deze
lokale variabele num is binnen de functie gewijzigd en de waarde ervan is gewijzigd.
Dat is niet normaal. Dat concept hebben we tot nu toe niet geleerd. Dat is doorgegeven door middel van verwijzing.
Maar in c wat er gebeurt, is dat je een kopie van het adres doorgeeft.
Daarom is het echt overbodig, we hebben de constante niet eens nodig, want zelfs als we
de waarde van de aanwijzer zouden veranderen, is het een kopie
van de waarde van de aanwijzer, dus je hoeft dat niet echt te doen.
Als we nu geen bestaand nummer willen gebruiken, kunnen we een aanwijzer maken, we hoeven
er alleen maar geheugen voor toe te wijzen.
Dus wat we hier zouden moeten doen, is dat we een int star num kunnen maken.
Maar wat we zouden moeten doen, is dat we eerst de malloc
moeten casten omdat malloc terugkomt met een
lege aanwijzer, maar we kunnen geheugen dynamisch toewijzen.
En hier zouden we eigenlijk moeten zeggen,
gewoon omdat we één geheel getal creëren, we zouden gewoon de grootte van int
kunnen zeggen en dat zou geheugen voor ons toewijzen.
En dan hoeven we alleen maar naar square num over te gaan.
En als we
dit bouwen, zou het hetzelfde doen, maar
nu heeft het ook geen waarde voor
num, dus zou niet echt
weten wat te berekenen, dus je zou de
waarde van num moeten toewijzen we zullen hier
vier zeggen, je de-refereert ernaar. En als je het nu bouwt en uitvoert,
zou je 16 moeten krijgen.
Het enige wat hier is, is dat we de waarde willen afdrukken, dus we willen num zeggen.
En als we het uitvoeren, zouden we 16 moeten zien.
En het is eigenlijk gewoon hetzelfde soort gedrag,
en we zien er 16.
Het enige verschil hier was dat we geheugen toewijsden
voor waar het punt naar verwijst, in tegenstelling tot alleen maar wijzen naar
een bestaande geheugenlocatie met ampersand.
Nogmaals, belangrijke dingen om hier op te merken, dit nummer verandert
buiten de functie. Dit is
doorgegeven door middel van verwijzing begrijpen. Waar we de de-referentie-operator gebruiken, de indirecte-operator
om de waarde te krijgen van waar het punt naar verwijst.
Begrijp dat als de functie een aanwijzer nodig heeft en we hebben
een aanwijzer, we gewoon de naam kunnen verzenden.
Als het geen aanwijzer nodig heeft
en het is eigenlijk een waarde, dan
moeten we het de-refereren. En dit is net als de scanf.
Dus hier zouden we de ampersand moeten zeggen.
En ook als we het uitprinten, hoeven
we niets te de-refereren omdat het geen aanwijzer is en
dan zou dat hier hetzelfde zijn.
En begrijp dan const twee. Const voor de int-ster zegt dat
de waarde waarnaar het punt wijst niet kan veranderen.
De const na de int start zegt dat het adres van de aanwijzer de waarde van de aanwijzer niet kan wijzigen.
Ik hoop dat dit nuttig was.
Nogmaals, speel hier wat mee, verander wat syntaxis, rotzooi zoals ik deed.
Het zal je helpen veel te leren. Dank u.