Hallo, en welkom terug
In deze lezing wil ik een demonstratie geven van onze
uitdaging voor het rekenen met aanwijzers en het gebruik van de constante modifier.
Laten we codeblokken naar voren brengen. Ik ga een nieuw project aanmaken. We gaan dit
rekenvoorbeeld met één aanwijzer noemen.
Dus wat we hier gaan doen, is dat
we de lengte van een string gaan bepalen door puntberekeningen te gebruiken.
Dus het eerste dat ik wil doen, is mijn functiedeclaratie maken.
Dit gaat de lengte van de string teruggeven. Dus het zal int hebben
als een retourtype. Ik noem het de lengte van de
string, en hier is alleen een aanwijzer voor nodig, maar het zal een constante aanwijzer zijn.
We willen de waarde van datgene waarnaar wordt verwezen niet veranderen.
Dus dat betekent dat we de constante als het eerste sleutelwoord zouden gebruiken, en
dan zouden we het type specificeren, wat een teken is.
En we zouden ster zeggen, en we kunnen het noemen wat we willen, string.
Nogmaals, gewoon om te herhalen, als we in plaats daarvan de constante hier hadden geplaatst, zou
dit zeggen dat het adres van de aanwijzer, de waarde
van de aanwijzer niet kan veranderen.
Maar nogmaals, het is een beetje overbodig en het hoeft niet echt te
worden gedaan omdat we pass by value pass by copy doen.
Je hebt dus sowieso een kopie van het adres, dus het maakt niet uit of je het daar wijzigt.
Maar het is belangrijk om te veranderen waarnaar u verwijst. Als je niet wilt dat de
waarde van wat je aanwijst, verandert, wil je hier zeker constant blijven, en
dat is belangrijk.
Dus nu hoeven we alleen nog maar onze main te maken.
maak onze belangrijkste. Het enige dat we in
ons hoofdmenu gaan doen, is dat we
stringlengte gaan aanroepen, een stringlengtefunctie met verschillende strings.
Dus laten we printen, en onthoud dat het een geheel getal retourneert, zodat we procent d kunnen zeggen en we
gaan gewoon de lengte uitprinten van een paar strings die we doorgeven.
Dus we gaan stringlengte noemen, en we
gaan gewoon wat constante strings invoeren, dus we kunnen dingen
hier tussen dubbele aanhalingstekens zetten. We hoeven niet eens pointers te maken.
Je zou een aanwijzer kunnen maken en deze toewijzen en vervolgens doorgeven, maar je moet
er alleen voor zorgen dat het een constante is.
Maar omdat het gemakkelijker is in minder code, kunnen we gewoon zeggen: tekenreekslengtetest.
Nogmaals, dat is een constante letterlijke reeks.
We zullen het met wat meer testen.
We plaatsen er een spatie achter. Laten we wat regelfeeds toevoegen.
Hier noemen we stringlengte. En laten we het eigenlijk met de lege string
noemen, zorg ervoor dat we nul draaien. En dan
onze derde zeggen we snaarlengte, we
zeggen gewoon Jason.
Toevallig, wanneer u deze maakt en deze koppelingen met
stringlengte doorgeeft, krijgen ze automatisch de nul-terminator toegevoegd.
Dat leren we als we pointers declareren.
Dat is een van de voordelen. Als je een aanwijzer gaat maken en het
wordt een letterlijke, dan wil je de grootte niet specificeren.
Je zou iets als karakter willen doen als het een array is, omdat
een array een array is een aanwijzer. Maar als we
de grootte niet willen specificeren, kunnen we
teken p zeggen en dan hier binnen kunnen we gewoon jason zeggen.
Onthoud die les waarin, als we de grootte voor tekenreeksen niet specificeren, het automatisch
een null-terminator zal toevoegen en de grootte voor u zal creëren.
Zo maak je geen fouten. Als u de grootte in de array
plaatst, heeft u mogelijk niet genoeg van de nulterminator.
Het is hetzelfde als we de letterlijke waarde doorgeven aan de tekenreekslengte,
de nul-terminator wordt aan het einde toegevoegd.
Dus we hadden deze variabelen in eerste instantie
kunnen maken en zoiets als dit kunnen doen en
vervolgens elke variabele hebben doorgegeven.
Maar ik wilde geen tijd verspillen aan het maken van variabelen. Dus dat ga ik gewoon doen.
Wat echt belangrijk is voor deze code, is de functie.
Dus we gaan onze stringlengte maken. Onthoud nogmaals, het retourneert een geheel getal
en het wordt een constante. Dus we kunnen gewoon zeggen constante tekenreeks ster.
En je merkt ook dat de naam van de
functiedeclaratievariabele niet overeen hoeft te komen. Ik zou dit als strings kunnen zetten en dat is ook prima.
Binnen deze functie moeten we een lokale aanwijzer maken omdat de lokale aanwijzer naar het
einde van de tekenreeks gaat wijzen. En als we eenmaal het adres voor het einde
van de string hebben, kunnen we het adres voor het begin van de string minnen.
Het adres voor het begin van de tekenreeks is wat wordt doorgegeven.
String wijst automatisch naar het eerste element in de array of het
eerste adres van de array.
Dus als we een lokale aanwijzer maken en
we willen gewoon opnieuw een constante char-ster maken en
we zullen gewoon het laatste adres zeggen, wat dacht je van.
En dit zal gelijk zijn aan het beginadres van de string, en dan
gaan we het elke keer in onze lus verhogen.
Dus nu hebben we het laatste adres. Nogmaals, dit is een lokale
variabele die het adres net voor de null-terminator gaat opslaan.
Dus nu kunnen we onze while-lus schrijven.
En onze while-lus wordt afgesloten als we de nulterminator zien.
Nu zouden we dit op twee verschillende manieren kunnen doen.
We zouden karakters kunnen vergelijken. Dus we zouden zoiets kunnen zeggen
als het laatste adres van de ster, omdat we de verwijzing moeten
verwijderen, het is niet
gelijk aan een backslash nul zou zoiets kunnen doen,
maar dat is nogal wat code. Het enige wat we echt hoeven
te doen, is zeggen
terwijl ster op het laatste adres. Want als je een
nulterminator derefeert, wordt deze gelijk aan
nul en nul is gelijk aan onwaar.
We weten dat Booleans één hebben is waar, nul is onwaar.
Dus als het onwaar is, springt het eruit. Dus alles wat u hoeft
te doen is binnen uw while-voorwaarde is het laatste adres van de ster.
Nogmaals, dit gaat de aanwijzer dereferentie.
En als het eenmaal naar het laatste adres wijst, zal het naar de nulterminator wijzen.
Nu moeten we ervoor zorgen dat we het laatste adres wijzigen, zodat het uiteindelijk naar de nulterminator wijst.
Hier kunnen we alleen plus plus laatste adres zeggen.
Dus elke iteratie van deze while-lus zal het adres verhogen totdat het
een nul ziet.
Een nul vertegenwoordigt de nulterminator.
Dus het eindresultaat van nadat deze while-lus
is uitgevoerd, zal het laatste adres naar het adres van de nulterminator wijzen.
We kunnen dan het adres van de null-terminator aftrekken van
het adres dat is doorgegeven, onze string, en dat geeft ons onze lengte.
Dus dat is alles wat we moeten doen op de volgende regel. We kunnen gewoon zeggen dat we
ons laatste adres teruggeven
en we willen het adres
eigenlijk minnen, dus we hoeven niets te de-refereren of de
indirecte-operator, laatste adres minus string te gebruiken. Dus string wordt doorgegeven, we
passen het helemaal niet aan.
Dat wijst naar het eerste teken. Dat zou wijzen op j.
Dat zou het adres zijn of voor de eerste keer dat we in lijn acht bellen, dat zou het adres zijn van s.
Het laatste adres zal verwijzen naar het adres van deze laatste t.
Eigenlijk één meer dan dat, de nulterminator. Als we het laatste adres zeggen
min het adres van s, dan krijgen we de lengte.
En daar gaan we op terugkomen.
Dus ik hoop dat het logisch is.
Nogmaals, op regel 17 maken we een lokale
variabele omdat we het laatste adres, het adres van de
nulterminator, moeten bijhouden.
Nadat deze while-lus is uitgevoerd, wijst het laatste adres naar na
de t, de nul-terminator.
Dan kunnen we gewoon het laatste adres van de string aftrekken, het adres van
de string wijst naar s als het binnenkomt, we veranderen dat niet.
Dus laten we eens kijken wat als dit ons de juiste lengte teruggeeft.
Wanneer we dit uitvoeren, zouden we de lengte moeten zien van de strings die we hebben doorgegeven.
We zien dus 17 0 en 5.
Laten we eens kijken 1 2 3 4 5 6 7 8
9 10 11 12 13, je moet de ruimte tellen, 14
15 16 17. Dat klopt, we plaatsen
dubbele aanhalingstekens die leeg zijn, dus dat zou nul moeten zijn en
dan zou Jason 5 moeten zijn, dus 17 0 en 5, dat klopt.
Dus wat we hier deden, was dat we
aanwijzerberekeningen gebruikten om het laatste adres plus de ophogingsoperator te krijgen,
en vervolgens onze rekenkunde wijzen om
de lengte te krijgen door het laatste adres minus de tekenreeks te minen.
Best netjes. Ik probeer de kracht
van puntberekeningen aan te tonen, het notatiegemak ervan.
Hoe u gemakkelijk kunt verhogen, verlagen om op
verschillende plekken in een tekenreeks te komen en
de tekens eruit te halen. In dit geval krijgen we alleen de adressen en gebruiken
we de adressen om elkaar te minen om de lengte te krijgen.
Dus ik hoop dat dit nuttig was. Zorg ervoor dat je alles begrijpt wat ik zojuist heb genoemd.
Nogmaals, het concept van een constante, het concept van plus plus, het concept van
de voorwaarde als je een adres derefereert en dat
wijst naar een nul-terminator, het is een nul, dus het springt eruit, en dan
dit concept van minus twee adressen. Dank u.