Vi ved, at pointervariablen kan gemme hukommelsesadressen på C-sprog, og i denne artikel vil vi lære, hvordan man bruger denne markør til at få adgang til dataene, der er gemt i hukommelsesplaceringen, som markøren peger på.
Hvad er en pointer?
Først og fremmest reviderer vi, hvad der er en pointer. En pointer er en variabel, der gemmer hukommelsesadressen for en anden variabel. Markøren hjælper os med at manipulere dataene i hukommelsesadressen, som markøren peger på. Desuden kan flere pointere pege på den samme hukommelse.
Overvej følgende eksempel,
int num = 10; int *ptr; ptr = #>
Vi har gemt adressen på på en variabel i ptr pointer, men nu, hvordan man får adgang til den værdi, der er gemt i hukommelsen på den adresse, der peges af ptr ? Her kommer dereferencing ind i billedet.
Dereferencepointer i C
At få adgang til eller manipulere indholdet, der er lagret i hukommelsesadressen, der peges af markøren ved hjælp af dereferencing eller indirektionsoperator (*), kaldes dereferencing af markøren.
Derhenvise pointer i C
Syntaks til at bortreference en pointer
Vi bruger indirektionsoperatoren (*) som præfiks for at dereferere en pointer:
* ( pointer_name )>
Til at ændre de data, der er gemt i hukommelsen, bruger vi
* ( pointer_name ) = new_value;>
Det skal bemærkes, at new_value skal være af samme type som den forrige.
Overvej ovenstående eksempler hvor ptr peger på om, t Indholdet i hukommelsesadressen kan tilgås af dereferencing-operatøren *. Nu vil *ptr'en hente indholdet, der er gemt i adressen, som er 10.
num og ptr hukommelsesadressen og værdierne vil se sådan ud.
| Variabel | Hukommelsesadresse | Værdi |
|---|---|---|
| antal = 10 | 202020 | 10 |
| 202021 | ||
| 202022 | ||
| 202023 | ||
| ptr = &num | 202024 – 202032 | 202020 |
Bemærk: Vi har antaget, at arkitekturen i ovenstående eksempel er byteadresserbar, dvs. minimumsenhed, der har en separat adresse, er en byte.
Eksempler på pointer-dereference
Eksempel 1:
Brug af en markør til at få adgang til og ændre værdien af en heltalsvariabel.
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;> }> |
>
>
js global variabel
Produktion
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>
Eksempel 2: Derhenvisning af dobbeltpointer
Dobbeltmarkørerne kan også dereferences ved hjælp af den samme logik, men du bliver nødt til at bruge indirektionsoperatoren to gange: En for at flytte til den markør, som dobbeltmarkøren peger på, og den anden for at få adgang til den faktiske værdi.
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;> }> |
>
>Produktion
Accesing value from double pointer using **dptr: 10>
Lige sådan kan vi dereferere pointer på ethvert niveau.
Hvordan fungerer dereferencing?
Når vi beder compileren om at dereferere en pointer, gør den tre ting:
- Den slår først adressen op, der er gemt i markøren.
- Derefter leder den efter typen af pointer, så den kan udlede mængden af hukommelse, der skal læses. For eksempel 4 byes for int, 1 byte for char osv. Det er også hovedårsagen til, at vi skal angive pointertypen i deklarationen, selvom størrelsen af hver pointer i et system er den samme.
- Til sidst læser den hukommelsen og returnerer de lagrede data.
Bemærk: Ud fra ovenstående ræsonnement kan vi også udlede, at vi ikke kan afreferere tomrumsmarkøren, da størrelsen af de data, den peger på, er ukendt. Så vi er nødt til at typecaste void-markøren for at dereferere den.