Kärnskillnaden mellan pekare och variabler ligger i vad de har:
* variabel: En variabel har ett * värde * direkt. Tänk på det som en behållare som lagrar data, som ett nummer, ett tecken eller en sträng. När du förklarar en variabel tilldelar du utrymme i minnet för att hålla dessa data.
* pekare: En pekare har en *minnesadress *. Denna adress pekar på platsen i minnet där ett annat värde lagras. Det är som att ha ett papper med en adress skriven på det - själva adressen är inte huset (värdet), men det berättar var du hittar huset.
Här är en analogi:
Föreställ dig en stad.
* variabel: Ett hus i staden. Huset innehåller något (möbler, människor etc.). Husets adress är inte en del av vad som finns i huset; Det är husets läge.
* pekare: Ett papper med adressen till ett hus skrivet på det. Själva papperet innehåller inte husets innehåll, bara adressen för att hitta det.
i kod (C ++ Exempel):
`` `C ++
#include
int main () {
int x =10; // x är en variabel som innehar värdet 10
int* ptr; // ptr är en pekare till ett heltal (det pekar inte på någonting ännu)
ptr =&x; // PTR pekar nu på minnesadressen till x
std ::cout <<"värde på x:" <
std ::cout <<"Adress till x:" <<&x <
std ::cout <<"Värde på ptr:" <
std ::cout <<"Värde pekad på av ptr:" <<*ptr <
return 0;
}
`` `
I det här exemplet:
* `X` är en variabel som direkt lagrar heltalsvärdet 10.
* `PTR` är en pekarvariabel. `&X` ger oss minnesadressen till` x ', och vi tilldelar den adressen till `ptr`. `*PTR` (DereFerence Operator) åtkomst till värdet på minnesadressen lagrad i` PTR '.
Nyckelskillnader sammanfattade:
| Funktion | Variabel | Pekare |
| ---------------- | -------------------------------------- | ---------------------------------------------- |
| håller | Värde | Minnesadress |
| deklaration | `Int x;` (t.ex.) | `Int* ptr;` (t.ex.) |
| Access | Direkt (t.ex. `x`) | Indirekt (med DereFerence Operator `*`) |
| minne | Minne tilldelad för att lagra värdet | Minne tilldelad för att lagra adressen |
Pekare är kraftfulla men kan vara svåra att använda korrekt. De är viktiga för dynamisk minnesallokering, länkade listor, träd och andra avancerade datastrukturer. Emellertid kan felaktig användning av pekare leda till minnesläckor och segmenteringsfel. Många språk på högre nivå (som Python, Java och C#) erbjuder skräpinsamling och dölj pekare från programmeraren för att förenkla utvecklingen och förbättra säkerheten.
