Vi vet at pekervariabelen kan lagre minneadressen på C-språk, og i denne artikkelen vil vi lære hvordan du bruker pekeren for å få tilgang til dataene som er lagret på minneplasseringen som pekeren peker på.
Hva er en peker?
Først av alt reviderer vi hva som er en peker. En peker er en variabel som lagrer minneadressen til en annen variabel. Pekeren hjelper oss å manipulere dataene i minneadressen som pekeren peker. Dessuten kan flere pekere peke til samme minne.
Tenk på følgende eksempel,
int num = 10; int *ptr; ptr = #>
Vi har lagret adressen til på en variabel i ptr peker, men nå, hvordan få tilgang til verdien som er lagret i minnet på adressen pekt av ptr ? Her spiller avstand inn.
Referansepeker i C
Å få tilgang til eller manipulere innholdet som er lagret i minneadressen som pekes av pekeren ved å bruke dereferensing eller indirektionsoperator (*) kalles å dereferere pekeren.
Avvisende peker i C
Syntaks for frareferanse til en peker
Vi bruker indirektionsoperatoren (*) som prefiks for å derifisere en peker:
* ( pointer_name )>
For å endre dataene som er lagret i minnet, bruker vi
* ( pointer_name ) = new_value;>
Det skal bemerkes at new_value må være av samme type som den forrige.
Tenk på eksemplene ovenfor hvor ptr poeng til om, t innholdet i minneadressen kan nås av den derefererende operatøren *. Nå vil *ptr hente innholdet som er lagret i adressen som er 10.
num og ptr minneadressen og verdiene vil se slik ut.
| Variabel | Minneadresse | Verdi |
|---|---|---|
| tall = 10 | 202020 | 10 |
| 202021 | ||
| 202022 | ||
| 202023 | ||
| ptr = &num | 202024 – 202032 | 202020 |
Merk: Vi har antatt at arkitekturen i eksemplet ovenfor er byteadresserbar, dvs. minimumsenhet som har en separat adresse er en byte.
Eksempler på pekereferering
Eksempel 1:
Bruke en peker for å få tilgang til og endre verdien av en heltallsvariabel.
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
Produksjon
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: Avreferanse dobbelpeker
De doble pekerne kan også skilles fra ved å bruke samme logikk, men du må bruke indirektionsoperatoren to ganger: En for å flytte til pekeren dobbeltpekeren peker på og den andre for å få tilgang til den faktiske verdien.
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;> }> |
>
>Produksjon
Accesing value from double pointer using **dptr: 10>
Akkurat slik kan vi avvise pekere på alle nivåer.
Hvordan fungerer det å referere?
Hver gang vi ber kompilatoren om å referere til en peker, gjør den tre ting:
- Den ser først opp adressen som er lagret i pekeren.
- Deretter ser den etter pekertypen slik at den kan utlede mengden minne som skal leses. For eksempel 4 byes for int, 1 byte for char osv. Det er også hovedgrunnen til at vi må spesifisere pekertypen i deklarasjonen selv om størrelsen på hver peker i et system er den samme.
- Til slutt leser den minnet og returnerer lagrede data.
Merk: Fra resonnementet ovenfor kan vi også slutte at vi ikke kan avreferere tomromspekeren da størrelsen på dataene den peker på er ukjent. Så vi må typecaste void-pekeren for å avreferere den.