Hallo, en welkom terug.
In deze lezing wil ik het hebben over de const-modifier en hoe
we deze gebruiken met pointers.
We hebben geleerd over constante eerdere lezingen.
Het betekent alleen dat u de waarde van een variabele niet kunt wijzigen. Maar wat betekent het als we het toepassen op een aanwijzer?
Dus wanneer we de const-modifier in een variabele of een array
gebruiken, vertelt het de compiler dat de inhoud van de variabele array niet door het programma zal worden gewijzigd.
Het alternatief was om definieer-instructies door de preprocessor te maken, maar const
is meestal een efficiëntere, betere manier om het te doen.
Met pointers moeten we twee dingen in overweging nemen bij het gebruik van een const-modifier.
Zeggen we eigenlijk dat de aanwijzer niet kan worden gewijzigd?
Of zeggen we dat de waarde waarnaar de aanwijzer verwijst niet kan worden gewijzigd?
Want onthoud dat een aanwijzer een waarde van een adres bevat.
En misschien willen we dat adres nooit veranderen.
Of misschien willen we de waarde waarnaar het punt verwijst niet veranderen.
In beide gevallen moeten we specifiek zijn in onze syntaxis.
U kunt dus het const-sleutelwoord gebruiken wanneer u een aanwijzer declareert om aan te geven dat de waarde waarnaar
wordt verwezen niet mag worden gewijzigd.
De manier waarop u dit opgeeft en nogmaals, zodat
de aanwijzer een waarde is, omdat een waarde een adres heeft.
Waar het naar verwijst is de waarde van dat adres.
Als je wilt dat dat niet verandert, zou
je zoiets doen.
Je zou zeggen dat wanneer je de aanwijzer declareert, je de asterisk in
de constante modifier vóór het type zou plaatsen.
Dus je zou zeggen constant, ongeacht het type dat je aanwijzer is, een sterretje.
Dit is dus eigenlijk vervormd en definieert een aanwijzer
naar een constante.
We kunnen 999l niet veranderen.
We verklaren dus dat de waarde waarnaar wordt verwezen door de pwaarde constant is.
De compiler controleert op alle instructies die proberen de waarde waarnaar wordt verwezen door de pvalue te wijzigen.
En als er een buddy is die dat in het programma doet, zal het een fout geven.
Dit is dus de syntaxis. Nogmaals, wat u hier
wilt opmerken, is dat const het eerste
woord is en vóór het type. Dus dat wil zeggen dat de waarde waarnaar wordt
verwezen niet kan veranderen.
Dus als je zoiets op pvalu probeert te doen, probeer dan een
waarde toe te wijzen aan datgene waarnaar wordt verwezen, omdat
je daar de indirecte-operator ziet. Dat betekent dat we een waarde
toekennen aan datgene waarnaar we verwijzen. Als we dat proberen,
geeft het een foutmelding omdat we die waarde niet
kunnen veranderen, 999l niet kunnen veranderen in 888l.
Dus hoe zit het nu met verwijzingen naar constanten.
En in de vorige verklaring hebben
we de aanwijzer gemaakt waarnaar het punt verwijst, kan niet veranderen.
Maar we kunnen nog steeds de werkelijke waarde wijzigen van de variabele die we hebben gedeclareerd.
We zouden dus nog steeds de lange waarde kunnen wijzigen.
We kunnen de p-waarde van de ster niet veranderen.
Maar lange waarde wordt niet gedefinieerd als een constante, maar wordt alleen gedefinieerd als lange waarde.
We kunnen dus nog steeds de waarde integer-pointer wijzigen
omdat er geen constante op is toegepast.
We hebben alleen constant op de aanwijzer toegepast. Dus we kunnen zeggen dat de waarde gelijk is aan 777l.
De waarde waarnaar wordt verwezen is gewijzigd, maar u hebt de aanwijzer niet gebruikt om de wijziging aan te brengen.
De aanwijzer zelf is ook geen constante.
De aanwijzer onthouden bevat een adres.
We hebben niet aangegeven dat de aanwijzer een constante is. Dus ook dat kunnen we
Wij, waar de aanwijzer naar wijst, zijn constant. nog veranderen. Als we een nieuwe variabele met de naam nummer hebben gedeclareerd, kunnen we zeggen
dat de p-waarde gelijk is aan het adres van dat nummer.
Dat is prima, want we veranderen het adres van de waarde van de aanwijzer.
We veranderen niet de waarde van waar de aanwijzer naar wees.
Dus begrijp dit onderscheid, ofwel de waarde van
de aanwijzer veranderen, die
slechts een adres is, ofwel veranderen waar de aanwijzer naar verwijst.
Als je niet wilt veranderen waar de
aanwijzer naar verwijst, moet const dat eerste sleutelwoord zijn in de verklaring van de aanwijzer zelf.
Dus nogmaals, in dit voorbeeld gaan we het adres dat is opgeslagen in p-waarde veranderen om naar een getal te wijzen.
We kunnen de aanwijzer nog steeds niet gebruiken om de waarde die is opgeslagen te wijzigen, omdat
die is gedeclareerd, omdat we die waarde niet kunnen wijzigen.
U kunt het adres dat in de aanwijzer is opgeslagen zo vaak wijzigen als u wilt, net zoals wij deden.
Het is niet toegestaan de aanwijzer te gebruiken om de waarde waarnaar wordt verwezen te
wijzigen, zelfs niet nadat u het adres hebt gewijzigd dat in de aanwijzer is opgeslagen.
Dus ook al hebben we het net
veranderd in een lang getal, de aanwijzer had nog steeds constant als sleutelwoord.
We kunnen de waarde dus niet wijzigen, ongeacht waar de aanwijzer naar wijst.
Hoe zit het met het niet toestaan dat het adres van
de aanwijzer verandert, de waarde die in de aanwijzer staat.
U wilt er dus ook voor zorgen dat het adres dat in de aanwijzer is opgeslagen, niet kan worden gewijzigd.
U kunt dit doen door het constante sleutelwoord in de declaratie
van de aanwijzer op dezelfde manier te gebruiken, maar het is iets anders.
In plaats van const als het eerste sleutelwoord te
hebben, zet je het achter het gegevenstype en na de asterisk.
Dit wil zeggen dat de aanwijzer zelf zijn waarde niet kan veranderen.
Als je het voor de int plaatst, zeg je dat de waarde waarnaar de aanwijzer verwijst, niet kan veranderen.
Dus wanneer u dit doet, zorgt het ervoor dat de aanwijzer altijd naar hetzelfde wijst.
Het adres zal nooit veranderen.
De compiler zal controleren of
u niet probeert om de aanwijzer ergens anders in uw code te wijzigen.
U kunt dit adres niet wijzigen.
Dus als je p count is gelijk aan en item, zou je een foutmelding krijgen.
Want dat kan alleen maar naar het teladres wijzen.
Het gaat erom waar je het constante zoekwoord plaatst als je wilt veranderen.
Als u niet wilt dat de aanwijzer naar de aanwijzer verandert of als
u niet wilt dat het adres van de aanwijzer verandert.
Constant, aangezien het eerste sleutelwoord niet toestaat dat de waarde van de verwijzingen naar de verwijzingen wordt gewijzigd.
Als je de constante achter het gegevenstype in de ster plaatst, wil dat zeggen
dat het adres van de aanwijzer niet kan veranderen.
Dus dat is veel om te nemen en dat is erg verwarrend, dus bestudeer wat ik net zei.
Begrijp die syntaxis, het is erg belangrijk en
het is erg lastig. Het kan heel gemakkelijk die
fout maken. Dus begrijp het verschil.
Je kunt de waarde waarnaar p
count verwijst nog steeds veranderen door p count te gebruiken, net zoals we dat in de vorige konden doen. Omdat p count is, hoewel we toewijzen dat we geen
nieuw adres kunnen toewijzen, kunnen we
nog steeds de waarde wijzigen waarnaar wordt verwezen.
Dus we kunnen het de-refereren en het op die manier veranderen. We kunnen zeggen dat het aantal sterren gelijk is aan 345, dat is prima.
Verwijst via de aanwijzer naar de waarde die is opgeslagen in count en verandert de waarde in 345.
Je kunt een constante aanwijzer maken die verwijst naar een waarde die ook een
constante is, dus je zou zoiets als dit kunnen doen, constant in
ster, constant p item.
En dat wil zeggen dat waar de waarde naar wijst
constant is en dat de aanwijzer zelf een constante is.
Dus p item is een constante pointer naar een constante, dus alles is vast.
U kunt het adres dat is opgeslagen in p item niet wijzigen en u kunt
p item niet gebruiken om te wijzigen waarnaar het verwijst.
U kunt het item echter nog steeds wijzigen.
Artikel is geen constante, dus u kunt het artikel wijzigen.
U kunt de waarde direct wijzigen.
Als u er zeker van wilt zijn dat er niets is gewijzigd,
moet u de variabele item int ook als een constante maken.
En dan zou dat zeggen dat het nooit zal veranderen.
Maar onthoud hier het verschil
tussen constante aanwijzers en constante waarden waarnaar de aanwijzer verwijst.
U kunt beide gebruiken. Je kunt het een of het ander gebruiken.
Als je er zeker van wilt
zijn dat alles constant is, zorg er dan voor dat wat je naar die variabele verwijst, die variabele ook constant is. Dank u.