Hallo en welkom terug. We hebben weer een uitdaging voor je.
In deze uitdaging wil ik dat je alles leert over aanwijzerberekeningen.
Onthoud dat aanwijzer rekenen een heel mooi concept is.
Het is een notatieconcept.
Maar het illustreert echt hoe arrays
gerelateerd zijn aan pointers. Je kunt heel gemakkelijk een array
doorlopen met een heel eenvoudige syntaxis die je coderegel verkleint en het is
echt een leuk concept.
Dus je gaat alles leren over aanwijzer rekenen.
We gaan ook meer leren over de constante modifier.
Dus in deze uitdaging wil ik dat je
een programma schrijft dat je begrip van aanwijzerberekeningen en de const-modifier test.
Over beide concepten hebben we in eerdere lezingen geleerd.
Dus ik wil dat je een functie schrijft die de lengte van de string berekent.
De vereisten zijn dat de functie als parameter een constante char-aanwijzer moet nemen.
Een constante char-aanwijzer betekent dat je de waarde van waar de aanwijzer naar wijst niet
kunt veranderen, en je gaat dat
ook niet doen met de lengte.
De functie kan de lengte van de string alleen bepalen met behulp van pointerberekeningen.
Ik wil niet dat je de str-lengtefunctie gebruikt. Ik wil dat je aanwijzer rekenkunde gebruikt.
En de manier waarop ik me voorstel dat deze functie wordt
geïmplementeerd, is dat je het adres van het einde van de aanwijzer krijgt.
Dat zou in wezen de lengte van de aanwijzer zijn.
Maar de manier waarop u het adres van de laatste tekenreeks en de aanwijzer kunt krijgen, is dat
u een while-lus kunt schrijven.
De while-lus kan helemaal naar het nulterminator-teken gaan.
Of het nul-terminator-teken, onthoud, dat wordt
weergegeven als int.
Dus de nulterminator is eigenlijk een nul. Dus je zou een while-lus
kunnen schrijven en de hele while-lus die in zijn voorwaarde moet
worden opgenomen, is de verwijzing naar de aanwijzer.
Want als de waarde van de d-referentiewijzer nul is, spring dan uit de lus
en dat zou de nulterminator zijn.
Dus ik wil dat je de hele
aanwijzer doorloopt.
En terwijl je er
doorheen gaat, blijf die aanwijzer verhogen.
Dus nu heb je een aanwijzer die naar het einde van de string wijst.
Om vervolgens de lengte daadwerkelijk te berekenen, hoeft u alleen
maar min twee wijzers te doen.
De aanwijzer die is doorgegeven waarin het begin van de
tekenreeks is en vervolgens de aanwijzer
die u hebt gemaakt in de functie die naar het einde van de tekenreeks wijst.
Als je het einde van de tekenreeksaanwijzer vanaf het begin van
het tekenreekspunt aftrekt, heb je de lengte van de tekenreeks.
Dus je gaat aanwijzerberekeningen doen door de aanwijzer
één voor één te verhogen om bij het eindadres te komen en
dan gebruik je puntberekeningen om elke aanwijzer af te trekken.
Dit is waarschijnlijk de meest geldige manier om puntberekeningen
te gebruiken voor aftrekken. Meestal voeg je geen twee pointers
toe, want waarom zou je twee adressen toevoegen.
Je mag twee adressen aftrekken om te zien hoe ver twee elementen in een
array van elkaar verwijderd zijn,
dat zou logisch zijn, maar optellen niet. Dus om het nog maar eens te herhalen,
de functie kan alleen de lengte van de string bepalen met behulp van puntberekeningen.
Maak een lokale aanwijzer in uw
functie, verhoog die aanwijzer elke keer om aan het einde te
komen totdat u null-terminator ziet, een eenvoudige while-lus.
En als je eenmaal het eindadres hebt, heb je het
beginadres al, trek die twee wijzers af die je de lengte geven.
Je moet die lengte teruggeven als een int van de functie.
En dan kun je de werkelijke lengte gewoon zelf uitprinten.
Dus deze opdracht maakt je vertrouwd met puntberekeningen en ook met
het gebruik van de constante-modifier, omdat je de werkelijke waarde waarnaar het verwijst
niet wilt veranderen en ook twee
pointers wilt aftrekken en ook een while-lus wilt gebruiken waar je naar
kunt kijken de waarde van de aanwijzer zelf om
het null-teken te bepalen. Veel geluk.
In de volgende lezing zal ik een oplossing bieden. Dank u.