Hallo, en welkom terug.
Omdat rekenkunde een nogal moeilijk concept is om te begrijpen en te
begrijpen, wilde ik nog een laatste
voorbeeld doornemen dat dit concept echt demonstreert, het doet goed werk.
En als je dit voorbeeld begrijpt, zul
je geen probleem hebben met puntberekeningen.
Dus het eerste voorbeeld dat ik je wil laten zien, is het
effect van het toevoegen van een geheel getal aan een aanwijzer.
Dus als we aanwijzerberekeningen doen met optellen, kunnen
we zien hoe het werkt in termen van de adressen.
Dus hier in dit programma maak ik alleen maar een string,
een tekenreeks, het wordt een string genoemd.
En dan maak ik een karakteraanwijzer met de naam p.
Ik ga door de hele lengte van de string die
meervoudig is. Dus ik ga door de hele array.
Noem gewoon basic for loops sterkte lengte van meerdere maten en meerdere.
En dan print ik elke
daadwerkelijke string of elk teken binnen die array.
En ook wat ik doe dat ik het adres
weergeef en vervolgens
het adres met het werkelijke nummer dat ik eraan heb toegevoegd.
Laten we dus alleen naar de uitvoer hiervan kijken, want de
uitvoer laat een heel goed voorbeeld van puntberekening zien.
Dus laten we naar codeblokken gaan en dit uitvoeren.
Dus hier zijn we in codeblokken. Ik heb de code een beetje opgeschoond.
Ik gebruik str-lengte, stel een strn-lengte in omdat het extra is inbegrepen.
En ik wil dit gewoon uitvoeren.
Dus als ik dit uitvoer, zul je merken dat het je
laat zien hoe je geheugen eruitziet, en het laat je de waarden
zien die de puntberekeningen uitvoeren. Dus als je meerdere sub-0 zegt,
onthoud dan dat meerdere alleen een tekenreeks bevat.
Maar als we hiernaar kijken en we zeggen kijk naar
de array-inhoud, veelvouden van 0 is a, veelvouden van 1 is een spatie en de rest is string.
Dat is de reeks.
Direct hiernaast is hetzelfde als 0 toevoegen aan de aanwijzer en de verwijzing
naar de aanwijzer verwijderen, 1 optellen en 2 toevoegen.
En het laat je zien hoe je aanwijzerberekeningen kunt doen door de aanwijzer zelf
te dereferenteren en er getallen aan toe te voegen.
Dus de aanwijzer plus zeven dereferentie die je krijgt g.
Vervolgens laat ik u in de derde kolom de werkelijke
adressen zien terwijl we toenemen. Dus de adressen van elk
element in de array met behulp van de ampersand alleen
op de tekenarray, we zien het adres 060feff voor element 0 enzovoort.
En dan kijken we naar de adressen als we gewoon aan
de aanwijzer zelf toevoegen zonder deze te verwijden, en je zult zien
dat de adressen in een rij staan.
En dus kunnen we naar de syntaxis kijken om te zien wat hier aan de hand is
in termen van het eerste dat we daadwerkelijk weergeven, is de index in de array die slechts een teller is.
En dan geven we een procent c weer, wat het
teken in de array is.
Het volgende dat we laten zien, is de
verwijzing naar de aanwijzer plus I.
Dus wat we hier doen, is dat we I weergeven
en dan de dereferentie van aanwijzer plus I, de
werkelijke waarde.
Dus we
geven als de
d alleen de werkelijke teller weer en dan is
punt c onze dereferentie. Dus p is onze aanwijzer.
We zeggen gewoon p plus I, aanwijzer rekenen, en dan
dereferen we het.
En om de adressen
te krijgen, hoeven we alleen maar ampersand veelvoud
te zeggen en dan de index.
Om de eerste het adres van de aanwijzer hier te krijgen, zeggen we
gewoon p
plus I om de werkelijke teller te
krijgen die je laat zien hoe we die p
verhogen, we doen gewoon een p plus procent d.
Maar het demonstreert goed de
verschillende manieren waarop het geheugen dat we naar de
adressen verwijzen, daadwerkelijk wordt
weergegeven en hoe ze equivalent zijn aan
de verschillende indexen in een array en de daadwerkelijke aanwijzers.
Ik dacht dat dit het goed deed.
Ik wil nog een voorbeeld bekijken dat een ander goed werk
doet met betrekking tot aanwijzerberekeningen met longs. Want hier zijn dit
gehele getallen. Dus alles wat we hoeven te doen is
er een toevoegen en gaat automatisch naar de volgende byte, enzovoort. Laten we eens kijken naar wat we doen, we doen verlangens.
Dus in dit voorbeeld wilde ik ook laten zien hoe je hetzelfde kunt doen
met een lange en een lange aanwijzer.
Met de tekenaanwijzer was het gewoon een reeks tekenreeksen.
Maar zelfs voor lange arrays, die verschillende groottes hebben, kunnen
we ze nog steeds doorlopen met een aanwijzer
en je kunt zien hoe het aantal bytes daadwerkelijk verandert.
Dus ook al zeggen we dat we een lange aanwijzer hebben en we voegen er een aan toe, we voegen er eigenlijk
4 bytes aan toe omdat een lange een beetje groter is en dat zullen we in dit voorbeeld zien.
Laten we dit voorbeeld nu in codeblokken uitvoeren.
Dus hier is ons voorbeeld. Nogmaals, we hebben een integerteller, een lusteller.
We hebben een lange array van 15l.
We specificeren l door het achtervoegsel op te zetten, dan specificeren we hun
l's, hun lange, we hebben een lange aanwijzer die naar meerdere wijst.
Nogmaals, omdat het een array is, hoeven we het adres van de operator niet te gebruiken.
We gaan de hele long doornemen. Hier kunnen we geen roerlengte gebruiken waarvan we
de grootte moeten gebruiken, en we moeten het eigenlijk delen door elke plek in de array.
Dus de totale grootte gedeeld door de enkele plek in de
array, dat is wanneer we eruit willen
springen omdat deze onze adressen onthouden die elk met 4 bytes toenemen.
En nogmaals, wat we hier doen, is dat we zowel de aanwijzer
als de array weergeven en je laten zien hoe ze
gerelateerd zijn, en dan tonen we het werkelijke totale
aantal bytes dat de lange op ons systeem staat.
En dus laat dit opnieuw zien hoe arrays
gerelateerd zijn aan pointers.
Dus als we dit
uitvoeren, zullen we vergelijkbare uitvoer zien. Maar wat hier een beetje anders
is, is de adresgrootte, die met 4 bytes toeneemt. Dus we gaan het adres en de aanwijzer afdrukken.
Dus voor het adres en de aanwijzer plus
0, zal dat gelijk zijn aan
de array sub 0 die adres 6356728 is.
En om de verwijzing naar de aanwijzer te verminderen, krijgen we de waarde van 15.
Dus p plus 0 zal nog steeds gelijk zijn aan de array sub 0.
En nogmaals, we doen hetzelfde voor p plus één p plus 2 en
p plus 3, allemaal gelijk aan de juiste plekken in de array voor de index.
De adressen gaan met 4 bytes omhoog, maar we kunnen nog steeds een 2 en 3 toevoegen en
we zien dat de waarden hetzelfde zijn.
En dan vertelt het ons dat deze long 4 bytes in beslag neemt en dat daarom de adressen met 4 worden verhoogd.
Wat hier belangrijk is, is dat we er nog steeds een kunnen toevoegen
en de compiler weet dat hij naar het volgende adres moet gaan.
Dus of we nu een lang of een teken hebben of wat
dan ook dat specifieke gegevenstype in het systeem zit, het toevoegen
van één of twee zal het juiste aantal bytes toevoegen.
Dus nog een cool voorbeeld dat ik je
wilde laten zien, omdat deze rekenkunde van de aanwijzer erg belangrijk is
en erg handig is bij het
herhalen of doorkruisen van een array, het maakt veel schoner en veel efficiënter.
Dus ik hoop dat dit heeft geholpen. Dank u.