Hallo, en welkom terug.
In deze lezing wil ik het hebben over toegang tot de
waarde waar een aanwijzer
naar verwijst. Dus onthoud aanwijzers, ze slaan geheugenadressen op.
Dat geheugenadres bevat eigenlijk een waarde van ergens.
En dus wijzen wijzers naar dat geheugenadres. Ik wil de waarde krijgen van
waar het naar verwijst.
Omdat ik gewoon de waarde van een aanwijzer zou afdrukken die een adres zou zijn, maar ik wil het adres krijgen, ik
wil de waarde van het adres krijgen.
U kunt dus toegang krijgen tot de waarde van een adres waarnaar een
aanwijzer verwijst met behulp van de indirecte-operator. De indirectie-operator is de asterisk.
Dus we hebben geleerd hoe we de asterisk kunnen gebruiken om een
aanwijzer te declareren, we gaan ook de asterisk gebruiken om de waarde te vinden waarnaar een aanwijzer verwijst.
Dus het wordt ook wel de dereferentie-operator genoemd, omdat je het
gebruikt om een verwijzing naar een aanwijzer te verwijderen.
Dus als je bijvoorbeeld een getal hebt dat gelijk is aan 15, declareer je de aanwijzer
van het type int, wijzend naar een int en je wijst het het adres van het getal toe met behulp van het ampersand.
Hoe krijg je nu de waarde van waar de aanwijzer naar verwijst.
U kunt de-refereren.
U kunt in feite de waarde waarnaar de aanwijzer verwijst, de
waarde 15 is, omdat deze verwijst naar het adres van het nummer dat 15 is.
Dus de pointervariabele bevat het adres van het variabelenummer.
U kunt dit in een uitdrukking gebruiken om een nieuwe waarde voor het resultaat te berekenen.
Dus stel dat we het resultaat wilden doen, is gelijk aan de
waarde waar de aanwijzer naar wijst plus vijf. U zou de asterisk ervoor
gebruiken vóór de naam van de aanwijzer.
En wat dit zou doen, is dat het in feite zou zeggen waar
de aanwijzervariabele naar verwijst, het wijst naar 15 en er vijf bij optellen.
Het is het adres
waarnaar de aanwijzer verwijst, wat de waarde van dat adres is.
Dus de asterisk van de indirecte
operator die u zou moeten opmerken, is ook het symbool dat wordt gebruikt voor vermenigvuldiging, en
het wordt ook gebruikt wanneer u aanwijzertypes declareert. Dit kan dus erg verwarrend zijn.
Hoe weet je per se wat er aan de hand is of hoe de compiler werkt.
Nou, het draait allemaal om de context. Het hangt af van wanneer u dat sterretje gebruikt en waar u het gebruikt.
Als u de asterisk gebruikt wanneer u een aanwijzer direct na het
type van
de aanwijzer declareert, dan gebruikt u duidelijk een declaratie.
Als u de asterisk tussen twee getallen
gebruikt, wordt deze gebruikt voor vermenigvuldiging. En als het wordt gebruikt
vlak voor de naam van de aanwijzer aan de rechterkant, bijvoorbeeld, of aan de linkerkant,
zal het een waarde toewijzen of toegang krijgen tot een waarde.
Het draait dus allemaal om context wanneer u deze
indirecte-operator gebruikt.
En zo werkt het.
Dus dat is hoe de compiler het gaat interpreteren.
Telkens wanneer je het in dit voorbeeld ziet, een
steraanwijzer en je hebt nog geen gegevenstype of je hebt geen twee
getallen aan elke kant, dan weet je dat het een indirecte aanwijzer is, dereferentie.
Laten we dus een voorbeeld doornemen. Hier is nog een
voorbeeld waarbij we een geheel getal gaan maken
dat gelijk is aan 10. We gaan ook een geheel getal van het type x maken, een andere variabele.
We initialiseren count tot 10, x wordt geïnitialiseerd op niets.
Vervolgens maken we een int-pointer. We weten dat het een int-aanwijzer
is omdat we het sterretje achter het gegevenstype
hebben staan en het vervolgens int-aanwijzer hebben genoemd.
We gaan nu aan die int-pointer het adres van count toewijzen.
Want onthoud, pointers bevatten alleen adressen als hun waarden, maar
ze verwijzen ook naar iets.
Dus we kunnen dan de variabele x toewijzen waar de int-aanwijzer ook naar verwijst, wat
is de waarde van het adres dat in de aanwijzer zit.
Dus x gaat daadwerkelijk 10 weergeven.
10. Dus als we doorgaan en dat gezegde
tel procent d ird x procent ird weergeven, tellen is gelijk aan 10, x wordt gelijk aan 10.
Dat is hoe je een aanwijzer kunt dereferenteren en de waarde ervan kunt krijgen. Het verwijst naar als u de
waarden van de aanwijzer wilt weergeven, want onthoud dat een aanwijzer
een waarde in het geheugen heeft, het
is slechts een adres. Dus wat als u
de waarde van de aanwijzers wilt weergeven, die wordt
weergegeven door een hexadecimaal geheel getal en adres?
Welnu, u kunt de formaatspecificatie procent p gebruiken. We hebben hier eerder over gesproken.
Hierdoor wordt een pointerwaarde als geheugenadres in hexadecimale vorm uitgevoerd.
Dus als we zoiets zouden doen,
waarbij we ons nummer declareren, we
verklaren onze aanwijzer, we initialiseren deze naar null, want dat is een goede gewoonte, we willen dat altijd doen
wanneer je iets in een verklaring niet aan de aanwijzer toewijst, maak zorg ervoor dat u het
initialiseert naar null.
We kennen dan onze nummervariabele 10 toe.
En dan wijzen we onze aanwijzer toe aan het adres van het nummer.
Dus de waarde van p-nummer wordt eigenlijk een adres.
een adres. Dus als we zouden proberen het uit te printen, zouden we procent p gebruiken en dat zou de waarde van het adres zijn.
Als we wilden afdrukken waar het naar verwijst, zouden we
het moeten de-refereren met behulp van de indirectie-operator.
Maar wanneer u het adres afdrukt, drukt het het af in
hexadecimaal, pointers nemen 8 bytes in het geheugen
in beslag en adressen hebben
16 hexadecimale cijfers. Dus hoe werkt dat?
Welnu, het hangt ervan af of uw machine 64-bits of 32-bits adressen ondersteunt.
Als uw machine een 64-bits besturingssysteem heeft,
ziet u 16 hexadecimale cijfers.
Als uw machine of uw besturingssysteem alleen 32-bits
adressering heeft, wordt de hexadecimale waarde weergegeven als 8 hexadecimale cijfers.
Wat nu als u een adres wilt weergeven.
U kunt zeggen wat het verschil is, omdat de aanwijzer een waarde heeft.
Maar u kunt het adres ook weergeven met het adres van de operator.
Dus in dit voorbeeld willen we het adres van het nummer weergeven.
Nummer is geen wijzer. Getal is gewoon een geheel getal.
Als we het adres daarvan willen weten, gebruiken we het ampersand.
Als we het adres daarvan willen weergeven, gebruik je gewoon opnieuw procent p.
Je past gewoon de ampersand toe.
Dus als we de ampersand met de aanwijzervariabele leveren, zouden we eigenlijk
het adres van die aanwijzer weergeven, niet
de waarde van het punt. Onthoud dat het adres van de aanwijzer een adres in het geheugen is.
De aanwijzerwaarde is een adres waarnaar deze verwijst.
En de waarde waarnaar het verwijst, bevindt zich ergens anders in het geheugen.
Dus onthoud die illustratie waarin
we lieten zien hoe aanwijzers werken.
Een aanwijzer, wanneer u deze declareert, creëert geheugen voor die aanwijzer,
8 bytes.
De waarde van die aanwijzer is een adres.
En waar die aanwijzer ook naar
verwijst, is een waarde, meestal van het type dat u hebt opgegeven.
Maar onthoud dat er eigenlijk drie delen zijn.
Als u het adres van de p-nummers wilt afdrukken, gebruikt u opnieuw het ampersand.
Dat zou het adres zijn van de daadwerkelijke aanwijzer.
En je zou de lege ster moeten gebruiken om een waarschuwing te omzeilen.
Dus onthoud dat een pointer zelf een adres heeft, net als elke andere variabele,
het wordt toegewezen wanneer je het declareert.
U gebruikt procent p als conversiespecificatie om adressen weer te geven.
U gebruikt de ampersand het adres van de operator om te verwijzen
naar het adres dat de p-getalvariabele inneemt.
Dat is het adres van de aanwijzer. Aan de andere kant heeft de aanwijzer
de waarde van een adres.
De cast a void is om een waarschuwing van de compiler
te voorkomen, met name de procent p-specificatie verwacht dat de waarde een soort aanwijzertype is.
Maar het type ampersand-nummer is een wijzer naar een wijzer ervan.
En dus moet je het casten.
Het aantal bytes weergeven dat een aanwijzer gebruikt.
Een andere manier om informatie over een aanwijzer te krijgen.
Hier kunt u de operator sizeof gebruiken. We hebben geleerd over de operator
sizeof om bytes van verschillende gegevenstypen weer te geven. U kunt hetzelfde doen met een aanwijzer.
Op een machine die ik gebruik, zal dit 8 bytes in beslag nemen.
En het machineadres heeft 64 bits omdat
het een 64-bits besturingssysteem is.
En u kunt een compilerwaarschuwing krijgen als u sizeof op deze manier gebruikt, sizet
is een door de implementatie gedefinieerd geheel getal.
Om de waarschuwing te voorkomen, zou je het argument kunnen casten naar een type int zoals dit.
Dus wat je zou doen, is zeggen p getalgrootte, procent d bytes.
En je zou zeggen int, giet het op een inch-grootte van p-getal.
Dat geeft je de grootte van de aanwijzer in het geheugen, de grootte van de aanwijzer
van dat adres, wat weer acht bytes is op de meeste systemen.
Want daar staat gewoon een adres in.
Hier nog een voorbeeld. Dit gaat een aantal dingen weergeven.
En we zullen dit voorbeeld uitvoeren om de uitvoer te tonen.
Maar net voordat we het uitvoeren, wil ik een beetje beschrijven wat hier aan de hand is. We hebben een nummer dat is gedeclareerd.
We hebben een aanwijzer die de null heeft geïnitialiseerd.
We stellen de waarde van het getal in op 10.
En wat we dan willen doen, is dat we
het adres van het gehele getal willen afdrukken, en we willen de waarde van het getal afdrukken,
heel eenvoudig, met het adres van de operator en dan alleen de variabele.
Wanneer we het adres van de operator doen, doen we procent p.
We gaan dan het adres van het nummer toewijzen aan onze aanwijzer.
We gaan dan wat pointer-informatie afdrukken.
We willen het adres van de aanwijzer zelf uitvoeren.
We kunnen gewoon procent p gebruiken, ongeldig ster-ampersand-nummer.
We willen zien hoeveel bytes die aanwijzer in het geheugen heeft. We kunnen zeggen sizeof.
We willen de werkelijke waarde van de aanwijzer zien,
wat een adres is. We kunnen gewoon het p-nummer zeggen
zonder extra informatie en dan gebruiken we procent p.
Als we de waarde willen zien waarnaar
de aanwijzer verwijst, de waarde op het adres, dan
doen we een ster p-nummer, we gebruiken de indirecte-operator.
En we weten dat het p-getal naar een in wijst, dus we kunnen procent d zeggen.
Laten we dus eens kijken naar dit voorbeeld in codeblokken om te zien hoe het daadwerkelijk wordt weergegeven.
Wat we gaan zien, zijn enkele hexadecimale
getallen voor adressen wanneer we adressen weergeven en in andere gevallen zullen we waarden zien.
Dit moet er dus bekend uitzien. Dit is slechts een programma dat
u laat zien hoe u toegang krijgt tot verschillende delen van een aanwijzer.
Dus nogmaals, we hebben een regulier nummergegevenstype int, en we hebben
onze aanwijzer. We initialiseren het naar null.
We gaan eerst ons nummer weergeven, dat is 10. Dus dit gaat het adres van nummer weergeven,
en dan gaat het de waarde van nummer weergeven op regel 10 en 11.
We gaan dan onze aanwijzer toewijzen, het adres van het nummer.
Als we het werkelijke adres van onze aanwijzer willen zien, gebruiken we gewoon de ampersand, het adres van
de operator, en we casten het naar de ster ongeldig.
We gebruiken procent p.
Als we willen zien hoeveel bytes de aanwijzer zich in het geheugen bevindt, doen we procent d sizeof.
Als we het adres de waarde van pinda de aanwijzer willen zien, doen we procent p
en zeggen we gewoon p getal, omdat p getal een adres is.
Als we willen zien waar de aanwijzer naar verwijst met de waarde van
het adres dat in de waarde van de aanwijzer staat, zeggen
we gewoon een asterisk p-nummer, we verwijzen ernaar, de indirecte-operator.
Dus laten we dit uitvoeren.
Als ik dit uitvoer, zie je de eerste twee dingen
die zijn afgedrukt, het adres van de
nummers op regel zes, en dat is een hexadecimaal getal, 0060ff0c.
En dit draait eigenlijk een 32-bits programma, dus je ziet dat het maar 8
bits is.
de getalvariabele die 10 is.
Vervolgens printen we het adres van de werkelijke aanwijzer naar het toegewezen geheugen.
Het is een ander adres dan nummer.
Omdat dit het adres is dat aan de aanwijzer is toegewezen.
De grootte van het pointernummer is 4 bytes, en dat
betekent dat het een 32-bits adressering is.
De waarde van de aanwijzer, het
adres van het nummer, zou hetzelfde moeten zijn, en dat is 0060ff0c.
En je ziet dat je het nummeradres daadwerkelijk kunt
krijgen door alleen de naam te gebruiken, de aanwijzer met procent p.
We zagen de grootte van de operator 4 bytes.
Als je de waarde wilt krijgen waar het p-getal naar verwijst, 10 is,
moet je de verwijzing naar de waarde verwijderen met behulp van de indirecte-operator en je ziet dat er 10 op staat.
Maar je ziet dat je procent p gebruikt wanneer
je adressen weergeeft, het procent e als je waarden van de integer-pointer of
het aantal bytes weergeeft.
Dit is dus de basissyntaxis voor toegang tot aanwijzerwaarden.
Adres van aanwijzer, ampersand, waarde waar het
punt naar verwijst, alleen de naam van de variabele
en de waarde van de aanwijzer zelf is alleen de naam van de variabele, en
vervolgens de waarde waarnaar de aanwijzer verwijst om de indirecte-operator te gebruiken.
Dank u. Ik hoop dat dit helpt. Bestudeer dit, doorloop dit.