Hallo, en welkom terug.
In deze lezing wil ik het hebben over de relatie tussen pointers en arrays.
Er is een sterke relatie en we moeten deze relatie begrijpen voordat we
echt kunnen praten over aanwijzerberekeningen. Dus laten we beginnen.
Een array is een verzameling objecten van hetzelfde type
waarnaar u kunt verwijzen met een enkele naam. We weten inmiddels dat we best goed zijn in arrays.
We gebruiken de tekenreeks nu al een paar secties.
Het is een array waartoe u toegang hebt door een index
of subscript tussen die haakjes te gebruiken. Dat herinneren we ons.
We weten dat arrays op nul zijn gebaseerd, ze beginnen bij nul.
Maar nogmaals, het is gewoon een manier om meerdere maanden vast te houden met dezelfde variabelenaam.
Een pointer is een variabele die zijn waarde heeft, een geheugenadres als zijn waarde,
en hij kan
verwijzen naar een andere variabele of constante van een bepaald type.
We moeten op dit punt ook vrij duidelijk zijn over wat een pointer is.
Het bevat alleen een geheugenadres.
U kunt een aanwijzer gebruiken om het adres van verschillende variabelen op verschillende tijdstippen vast te houden.
Maar je moet wel hetzelfde type hebben. Een int-pointer moet wijzen
om het adres van een int-type te herstellen.
Arrays en pointers lijken heel verschillend, maar
ze zijn zeer nauw verwant en kunnen soms door elkaar worden gebruikt,
vooral met de tekenarray.
U kunt een teken maken en onthouden wat een
tekenreeks is en u kunt een tekenaanwijzer maken die in wezen hetzelfde is.
Er zijn slechts kleine
verschillen of u geheugen toewijst en vrijmaakt met een tekenaanwijzer.
Bij een character array hoef je dat niet
te doen, maar een character a heeft ook een vaste grootte.
Dus als u een tekenreeksreeks maakt
met 20 als grootte, kunt u slechts 19 tekens opslaan.
Met de karakteraanwijzer kunt u dynamisch geheugenbeheer gebruiken en
kunt u de grootte vergroten of verkleinen, het kan efficiënter
zijn met betrekking tot geheugen.
Maar een van de meest voorkomende toepassingen van pointers in c is als pointers naar arrays.
Dit is wanneer u
het vaakst pointers gebruikt, vooral naar tekens.
Tekenaanwijzer is hetzelfde als een tekenarray.
De belangrijkste redenen voor het gebruik
van aanwijzers om te wissen zijn die van notatiegemak en programma-efficiëntie.
U kunt dus in veel gevallen ofwel een array ofwel een pointer gebruiken,
behalve wanneer u het hebt over dynamisch geheugenbeheer.
Maar in de meeste gevallen kan dat wel. En echt het enige verschil is de syntaxis,
het is de notatie.
Het gaat erom of je een subscript gebruikt om toegang te krijgen tot
een element of of je al dan niet
puntberekeningen gebruikt, of je de karakteraanwijzer al dan niet gebruikt om naar het specifieke adres van dat element te verwijzen.
Het is ook efficiënter om karakteraanwijzers te gebruiken.
Pointers naar arrays resulteren over het algemeen in code die minder geheugen gebruikt en sneller wordt uitgevoerd.
U wilt dus zoveel mogelijk een aanwijzer voor tekens gebruiken
en ook een aanwijzer naar andere gegevenstypen.
Omdat het sneller is en minder geheugen gebruikt. Pointers over arrays voor het grootste deel.
Als je een array van 100 gehele getallen hebt,
weten we wat dit betekent, je zegt gewoon dat de int-waarde 100 is. 100 is de maat.
Dat betekent dat je 100 gehele getallen in die array kunt opslaan.
U kunt ook een aanwijzer definiëren. We gaan het waardenaanwijzer noemen omdat het
naar de waardenarray verwijst en
het kan worden gebruikt om toegang te krijgen tot de gehele getallen in deze array.
Dus we zeggen gewoon instar-waardenaanwijzer. We weten nu hoe we een pointer moeten declareren.
Wanneer u een aanwijzer definieert die wordt gebruikt om de elementen van
een array te verwijzen, wijst u de aanwijzer niet aan als typeaanwijzer naar array.
Tot nu toe hebben we alleen maar gehoord van pointer to
end, pointer to double.
Maar als je arrays gebruikt, zeg je geen pointed array.
Die daadwerkelijke aanwijzer wijst naar een specifiek element in de array.
Houd daar dus rekening mee. Het is niet echt een hele array
wanneer u een aanwijzer wist met het adres van waarden.
Dus om de waardenaanwijzer zo in te stellen dat deze naar het eerste element van de waardenmatrix wijst, hoeft u
alleen maar te zeggen dat waarden wijzen op of gelijk zijn aan waarden.
Je hoeft het adres daar niet te zetten of zo. Omdat
waardenarray een aanwijzer is.
Dat is wat je in je hoofd moet rijden, al
deze arrays zijn wijzers onder de motorkap.
Dus als je het eerste element van een
array aan een pointer wilt toewijzen, hoef je alleen maar de array op te geven
aan de rechterkant van de equals-operator
en aan de linkerkant heb je alleen de waardenaanwijzer.
Dit gaat naar het eerste adres in de array of het eerste element.
De adresoperator wordt niet gebruikt, let op.
De c-compiler behandelt het uiterlijk van een arraynaam zonder
subscript als een verwijzing naar de array.
Dus het specificeren van waarden zonder een subscript heeft het effect
dat er een aanwijzer naar het eerste element van waarden wordt geproduceerd.
Dit betekent dat je nu naar volgende waarden in de array
kunt verwijzen door de aanwijzer te verhogen om naar het volgende adres te gaan.
En daar gaan we het in de volgende paar lezingen over hebben als we het hebben over puntberekeningen.
En het is eigenlijk gewoon een notatie-ding en het is ook een efficiëntie-ding.
Dus een equivalente manier om een aanwijzer naar het begin van waarden te produceren, is door ook
het adres van de operator toe te passen op het eerste element van rechts.
Je kunt het dus op twee manieren doen, beide manieren zijn prima.
Maar dit zou je ook kunnen doen. Je zou kunnen zeggen waarden pointer adres van waarde onder nul.
Dat zal de waardenaanwijzer naar het eerste element in de array plaatsen.
Dus je kunt deze gebruiken of je kunt gewoon zeggen dat waardenpunt gelijk is aan waarde.
Het is duidelijk dat zonder het ampersand en zonder
het subscript iets meer minder code of gemakkelijker te schrijven is.
Dit is misschien wat duidelijker omdat je
niet per se weet dat waarden een array zijn, tenzij je naar de declaratie kijkt.
Maar nogmaals, beide manieren zijn prima. Waardenwijzer is gelijk aan waarden of
waardenwijzer is gelijk aan adres van waarde onder nul.
Het is een kwestie van voorkeur van de programmeur. En nogmaals, het is een notatie.
Dus om het
nog maar eens te herhalen, als je twee uitdrukkingen
ar sub-i en asterisk ar plus i hebt,
zijn die equivalent in betekenis.
We willen er dus zeker van zijn dat u dit begrijpt.
Beide werken als ar de naam is van een array.
U kunt de aanwijzer gebruiken en u kunt ernaar verwijzen.
En beide werken als het een pointervariabele is.
Gebruik een uitdrukking zoals ar plus plus werkt alleen als ar een pointervariabele is.
U kunt een array dus niet verhogen door plus
plus te zeggen en verwachten dat deze naar het volgende element gaat.
U kunt dat alleen doen op arraypointers of pointers.
Dus als we ar hebben, is dat een aanwijzer die naar array verwijst en we willen naar
het volgende element gaan, we kunnen het gewoon elke keer verhogen.
Maar als je ar sub-i zegt omdat ar sub i een array is en
een array een aanwijzer is, kun je de verwijzing ernaar verwijderen door te zeggen dat
ar een aanwijzer is die
we hebben toegewezen aan ar plus i, dan is het hetzelfde.
Dus in de volgende paar lezingen gaan we het hebben over
puntberekeningen en dit hangt sterk samen met de relatie tussen arrays en pointers.
Pointers kunnen arrays zijn. Het is geen pointer-array, het is een element.
U kunt dus het adres van een aanwijzer gebruiken om
door een array te navigeren, door een
array te itereren. Dank u.