Hallo, en welkom terug.
In deze lezing wil ik het hebben over het definiëren van pointers, voornamelijk de syntaxis voor
het declareren van reporter en het vervolgens gebruiken van het adres van de operator om
een geheugenadres aan een pointer toe te wijzen.
Dus tot nu toe zouden we het op ons
hoofd moeten hebben dat een aanwijzer niets meer
is dan een variabele die naar een geheugenadres verwijst of een geheugenadres als waarde bevat.
Dus het declareren van een aanwijzer is niet hetzelfde als het maken van een normale aanwijzer.
Je kunt dus niet zoiets als een aanwijzer doen.
Dat is niet de manier om een pointer te declareren. De syntaxis is iets anders.
Je gebruikt een sterretje. Het is dus niet voldoende om te zeggen dat een variabele een pointer is.
U moet ook het soort variabele opgeven waarnaar de aanwijzer verwijst.
Verschillende typen variabelen nemen verschillende hoeveelheden opslagruimte in beslag.
Voor sommige aanwijzerbewerkingen is kennis van die opslaggrootte vereist.
Dus net als een gewone variabele wanneer u een gegevenstype
opgeeft, moet u bij het maken van een variabele
van een aanwijzergegevenstype ook dat gegevenstype specificeren.
U kunt een aanwijzer naar een variabele van het type int declareren door het
volgende te doen, int star of asterisk p-nummer.
Dat zal je vertellen dat dat een aanwijzing is.
De int ziet er hetzelfde uit, maar daarna is de asterisk.
Het sterretje geeft aan dat het een aanwijzer is en vervolgens geeft
u het type aanwijzer zelf op. Dit is een int-wijzer.
Het type van de variabele met de naam p getallen int star.
Het kan het adres van elke variabele van het type int opslaan.
Een aanwijzer slaat adressen op. Dus als je
het adres van een andere variabele wilt opslaan, moet
die variabele worden gedefinieerd als een geheel getal.
Dus hier wijst PI naar
int-variabele, char
star pc, dat verwijst naar een tekenvariabele, float
star pf star pg, dat zijn verwijzingen naar float-variabelen.
Dat is hoe je ze definieert, typen zijn belangrijk.
De spatie tussen de asterisk en de naam van de aanwijzer is optioneel.
Je hoeft daar geen spatie te plaatsen. Je kunt geen ruimte hebben.
Wat er uiteindelijk gebeurt, en
we gaan het hebben over dereferentie van een variabele, is dat je meestal een spatie gebruikt in de declaratie
en wanneer je dereferentie doet, gebruik je deze niet.
Dus al deze verklaringen moeten een spatie bevatten volgens afspraak.
De waarde van een aanwijzer is
een adres, dus het moet op de meeste systemen intern worden weergegeven als een niet-ondertekende afbeelding.
Er moet dus nog iets in opgeslagen worden. Het gebeurt zo dat het een hexadecimaal getal opslaat.
En hoewel het het opslaat omdat het eruitziet als een geheel getal, moet
je het niet zien als een geheel getal.
Dezelfde dingen die je met gehele getallen kunt doen, hoef je niet per se met pointers te doen en vice versa.
Dus ook al probeer je het uit te printen, het zal eruitzien als een getal een hexadecimaal getal, dit betekent niet
dat je het als een geheel getal kunt behandelen.
U kunt bijvoorbeeld het ene geheel getal met het andere
vermenigvuldigen, maar u kunt de ene aanwijzer niet met de andere vermenigvuldigen.
Een pointer is echt een nieuw type, het is geen integer type.
Het percentage p vertegenwoordigt het formaat dat is opgegeven voor pointers.
Ik ga door met het weergeven van de verschillende gegevens voor een aanwijzer en we zullen zien hoe dat wordt gebruikt.
De vorige declaraties maken de
variabele aan, maar er is geen initialisatie. Er is daar geen opdracht.
Je wilt altijd een waarde aan
een aanwijzer toekennen, het is erg gevaarlijk als je die niet initialiseert.
U wilt dus een aanwijzer initialiseren wanneer u deze declareert.
Als u niet weet waarnaar u het moet
initialiseren als het niet het adres van een andere variabele
is of als u er geen dynamisch geheugen voor hebt toegewezen, kunt u een null-aanwijzer gebruiken.
U kunt een aanwijzer dus initialiseren zodat deze nergens naar verwijst.
Dit doe je met null.
Je zegt dat het instar p-nummer gelijk is aan null voor een pointer naar een int.
Null is een constante die wordt gedefinieerd door de standaardbibliotheek.
Het is het equivalent van een nul voor een aanwijzer.
Het betekent dat het nergens naar verwijst.
Het wijst gegarandeerd niet naar een locatie in het geheugen.
Het is dus goed dat je dit wilt doen, want wat het betekent is dat je geen
fouten gaat maken door per ongeluk een bufferoverloop uit te voeren of door naar het
geheugen te schrijven waar je niet naar mag schrijven.
Door het hierop te initialiseren, beperkt het feitelijk enkele fouten die u kunt maken.
We hadden het eerder over null. We hadden het over het nulkarakter.
Dat concept is anders dan de nulwijzer.
Een null-pointer betekent dat het nergens naar verwijst, en daarmee moet het worden geïnitialiseerd.
U moet een include-instructie toevoegen voor standaarddef. h als u hier de
null-definitie wilt gebruiken.
Het adres van de exploitant. Als u uw aanwijzer aan een
adres wilt toewijzen,
kunt u de adresoperator van een bestaande variabele gebruiken.
Dus als je je variabele wilt initialiseren met de add- of subvariabele die je hebt, heb
je al aangegeven dat je het adres van de operator, de ampersand, gebruikt.
We hebben dit gezien toen we de scanf-functie bespraken.
Hier wijzen we een integerwaarde-variabele 99 toe.
We maken een aanwijzer van het type int en we wijzen deze het adres van het nummer toe.
We kunnen dit doen omdat nummer een int
is en de aanwijzer die we hebben gemaakt ook naar een int verwijst.
Dus alles wat we hoeven te doen na de operator is gelijk aan, is het ampersand gebruiken.
En dus gaat p nummer nu het adres van nummer bevatten.
De beginwaarde van p getal is het adres van het variabele getal.
De declaratie van het nummer moet voorafgaan aan de declaratie van de aanwijzer
die zijn adres opslaat,
omdat je aan een aanwijzer niet iets kunt
toewijzen waaraan geen geheugen is toegewezen.
Als u probeert om dat aanwijzernummer toe te wijzen, bestaat het nummer niet, tenzij u het daarna doet.
Om een adres aan een aanwijzer toe te
wijzen, moet er geheugen voor dat adres zijn toegewezen.
Anders gaat de compiler klagen.
Wees echter voorzichtig, want er is niets bijzonders aan de verklaring van een aanwijzer.
U kunt reguliere variabelen en pointers in dezelfde instructie declareren.
Dus je zou kunnen zeggen dubbele waarde, p waarde f num.
In deze verklaring hier is dit de
enige tweede variabele p val is een pointer, de andere twee zijn gewoon dubbelen.
Dat is een beetje explicieter, een beetje meer voor de
hand liggend in die verklaring. Maar wat als je in star pq
zegt, dit impliceert dat het beide wijzers zijn en dat zijn ze niet.
We hebben hier maar één int-aanwijzer die p is, de variabele
q is alleen om int te typen.
Het is een veelgemaakte fout om te denken dat zowel p als q pointers zijn.
Wees dus voorzichtig wanneer u een aanwijzer op veel variabelen op dezelfde regel declareert.
Het is ook een goed idee om namen die met p beginnen, als pointernamen te gebruiken.
Dit zal je vertellen dat die variabele een aanwijzer is door er gewoon naar te kijken.
Dus meestal doe je al je declaraties van variabelen bovenaan
een programma, meestal binnen de hoofdfunctie.
En als je die variabelen later in
het programma ziet gebruikt, kun je gemakkelijk de verschillende gegevenstypes of
de verschillende aanwijzertypes identificeren omdat ze p als voorvoegsel hebben.
Dus deze lezing ging net over
hoe je een pointer kunt definiëren, declareren en vervolgens een adres van
een bestaande variabele aan een pointer kunt toewijzen.
Nu zijn er gevallen waarin u niet noodzakelijkerwijs een
bestaande variabele een waarde van pointer wilt toewijzen, misschien wilt u nieuw geheugen toewijzen.
Daar gaan we het in de volgende lezing over hebben. Maar nu gaan we het simpel houden.
We gaan ons concentreren op het gebruik van pointers
van het type ints en verschillende eenvoudige typen zoals doubles of floats.
En we gaan ons concentreren op het
toewijzen van bestaande variabelen, het adres van en kijken hoe dat werkt.
Dus laten we vooruit gaan. Dank u.