We weten dat de pointervariabele het geheugenadres in C-taal kan opslaan en in dit artikel zullen we leren hoe we die pointer kunnen gebruiken om toegang te krijgen tot de gegevens die zijn opgeslagen in de geheugenlocatie waarnaar de pointer verwijst.
Wat is een aanwijzer?
Allereerst bekijken we wat een pointer is. Een pointer is een variabele die het geheugenadres van een andere variabele opslaat. De aanwijzer helpt ons bij het manipuleren van de gegevens in het geheugenadres waarnaar de aanwijzer verwijst. Bovendien kunnen meerdere pointers naar hetzelfde geheugen verwijzen.
Beschouw het volgende voorbeeld,
int num = 10; int *ptr; ptr = #>
Wij hebben het adres van de opgeslagen op een variabele in de ptr pointer, maar nu, hoe u toegang krijgt tot de waarde die is opgeslagen in het geheugen op het adres waarnaar wordt verwezen ptr ? Hier komt dereferentie in het spel.
Dereferentiewijzer in C
Het openen of manipuleren van de inhoud die is opgeslagen in het geheugenadres waarnaar de aanwijzer verwijst met behulp van dereferentie- of indirectie-operator (*) wordt het derefereren van de aanwijzer genoemd.
Hoe verander je de string in int?
Dereferentiewijzer in C
Syntaxis voor het derefereren van een aanwijzer
We gebruiken de indirectie-operator (*) als voorvoegsel om een aanwijzer te derefereren:
* ( pointer_name )>
Voor het wijzigen van de gegevens die in het geheugen zijn opgeslagen, gebruiken we
* ( pointer_name ) = new_value;>
Opgemerkt moet worden dat de nieuwe_waarde van hetzelfde type moet zijn als de vorige.
Overweeg de bovenstaande voorbeelden waar ptr wijst naar of, t De inhoud van het geheugenadres is toegankelijk voor de dereferentieoperator *. Nu haalt de *ptr de inhoud op die is opgeslagen in het adres dat 10 is.
Het num- en ptr-geheugenadres en de waarden zullen er als volgt uitzien.
| Variabel | Geheugenadres | Waarde |
|---|---|---|
| aantal = 10 | 202020 | 10 |
| 202021 | ||
| 202022 | ||
| 202023 | ||
| ptr = &num | 202024 – 202032 | 202020 |
Opmerking: We hebben aangenomen dat de architectuur in het bovenstaande voorbeeld byte-adresseerbaar is, dat wil zeggen dat de minimale eenheid die een afzonderlijk adres heeft een byte is.
tekenreeks vergelijken c#
Voorbeelden van pointer-dereferentie
Voorbeeld 1:
Een pointer gebruiken om toegang te krijgen tot de waarde van een integer-variabele en deze te wijzigen.
C
// C Program to illustrate the dereferencing of pointer> #include> int> main()> {> >// Declare integer variable number> >int> num = 10;> >// Declare pointer to store address of number> >int>* ptr = #> >// Print the value of number> >printf>(>'Value of num = %d
'>, num);> >// Print Address of the number using & operator> >printf>(>'Address of num = %d
'>, &num);> >// Print Address stored in the pointer> >printf>(>'Address stored in the ptr = %p
'>, ptr);> >printf>(>'Dereference content in ptr using *ptr
'>);> >// Access the content using * operator> >printf>(>'Value of *ptr = %d
'>, *ptr);> >printf>(>'Now, *ptr is same as number
'>);> >printf>(>'Modify the value using pointer to 6
'>);> >// Modify the content in the address to 6 using pointer> >*ptr = 6;> >// Print the modified value using pointer> >printf>(>'Value of *ptr = %d
'>, *ptr);> >// Print the modified value using variable> >printf>(>'Value of number = %d
'>, num);> >return> 0;> }> |
parallelle verwerking
>
>
palindroom in Java
Uitvoer
Value of num = 10 Address of num = 0x7ffe47d51b4c Address stored in the ptr = 0x7ffe47d51b4c Dereference content in ptr using *ptr Value of *ptr = 10 Now, *ptr is same as number Modify the value using pointer to 6 Value of *ptr = 6 Value of number = 6>
Voorbeeld 2: Dereferentie van dubbele aanwijzer
De dubbele pointers kunnen ook worden verwijderd met behulp van dezelfde logica, maar u zult de indirectie-operator twee keer moeten gebruiken: één om naar de pointer te gaan waar de dubbele pointer naar wijst en de andere om toegang te krijgen tot de werkelijke waarde.
C
// C program to dereference double pointer> #include> int> main()> {> >int> var = 10;> >int>* ptr = &var;> >// double pointer> >int>** dptr = &ptr;> >// dereferencing the double pointer> >printf>(>'Accesing value from double pointer using '> >'**dptr: %d'>,> >**dptr);> >return> 0;> }> |
verschil tussen tijger en leeuw
>
>Uitvoer
Accesing value from double pointer using **dptr: 10>
Zo kunnen we verwijzingen van elk niveau derefereren.
Hoe werkt dereferentie?
Telkens wanneer we de compiler vragen een pointer te derefereren, doet deze drie dingen:
- Het zoekt eerst het adres op dat in de aanwijzer is opgeslagen.
- Vervolgens zoekt het naar het type aanwijzer, zodat het de hoeveelheid te lezen geheugen kan afleiden. Bijvoorbeeld 4 byes voor int, 1 byte voor char, enz. Het is ook de belangrijkste reden waarom we het pointertype in de declaratie moeten specificeren, ook al is de grootte van elke pointer in een systeem hetzelfde.
- Ten slotte leest het het geheugen en retourneert de opgeslagen gegevens.
Opmerking: Uit de bovenstaande redenering kunnen we ook concluderen dat we de lege aanwijzer niet kunnen derefereren, omdat de grootte van de gegevens waarnaar deze verwijst onbekend is. We moeten dus de ongeldige aanwijzer typeren om er een dereferentie van te maken.