Vi vet att pekarvariabeln kan lagra minnesadressen på C-språk och i den här artikeln kommer vi att lära oss hur man använder den pekaren för att komma åt data som lagras på minnesplatsen som pekaren pekar på.
Vad är en pekare?
Först och främst reviderar vi vad som är en pekare. En pekare är en variabel som lagrar minnesadressen för en annan variabel. Pekaren hjälper oss att manipulera data i minnesadressen som pekaren pekar. Dessutom kan flera pekare peka på samma minne.
Tänk på följande exempel,
kantigt material
int num = 10; int *ptr; ptr = #>
Vi har lagrat adressen till på ett variabel i ptr pekare, men nu, hur man kommer åt värdet lagrat i minnet på adressen som pekas av ptr ? Här spelar bortseende in.
Referenspekare i C
Att komma åt eller manipulera innehållet som är lagrat i minnesadressen som pekas av pekaren med hjälp av avlednings- eller indirektionsoperator (*) kallas för att avleda pekaren.
Avvikande pekare i C
Syntax för bortreferensering av en pekare
Vi använder indirektionsoperatorn (*) som prefix för att hänvisa till en pekare:
* ( pointer_name )>
För att modifiera data som lagras i minnet använder vi
* ( pointer_name ) = new_value;>
Det bör noteras att new_value måste vara av samma typ som det föregående.
Tänk på ovanstående exempel där ptr pekar på om, t Innehållet i minnesadressen kan nås av den refererande operatorn *. Nu kommer *ptr att hämta innehållet som är lagrat i adressen som är 10.
Minnesadressen och värdena för num och ptr kommer att se ut så här.
10 ml till uns
| Variabel | Minnesadress | Värde |
|---|---|---|
| num = 10 | 202020 | 10 |
| 202021 | ||
| 202022 | ||
| 202023 | ||
| ptr = &num | 202024 – 202032 | 202020 |
Notera: Vi har antagit att arkitekturen i exemplet ovan är byteadresserbar, dvs minsta enhet som har en separat adress är en byte.
Exempel på Pointer Dereference
Exempel 1:
Använda en pekare för att komma åt och ändra värdet på en heltalsvariabel.
C
lexikografisk ordning
// 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;> }> |
>
>
konvertera byte array till sträng
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>
Exempel 2: Avlägsna dubbelpekare
Dubbelpekarna kan också avläsas med samma logik, men du måste använda inriktningsoperatorn två gånger: En för att flytta till pekaren som dubbelpekaren pekar på och den andra för att komma åt det faktiska värdet.
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;> }> |
kan en abstrakt klass ha en konstruktor
>
>Produktion
Accesing value from double pointer using **dptr: 10>
Precis så kan vi bortse från pekare på vilken nivå som helst.
Hur fungerar hänvisning?
När vi ber kompilatorn att hänvisa till en pekare gör den tre saker:
- Den letar först upp adressen som är lagrad i pekaren.
- Sedan letar den efter typen av pekare så att den kan härleda mängden minne som ska läsas. Till exempel 4 byes för int, 1 byte för char, etc. Det är också huvudorsaken till att vi behöver specificera pekartypen i deklarationen även om storleken på varje pekare i ett system är densamma.
- Slutligen läser den minnet och returnerar lagrad data.
Notera: Från resonemanget ovan kan vi också dra slutsatsen att vi inte kan avreferera tomrumspekaren eftersom storleken på data den pekar på är okänd. Så vi måste typcasta tomrumspekaren för att referera till den.