Pointers in Go är ett kraftfullt verktyg för att hantera minne och manipulera data. De tillhandahåller ett sätt att direkt referera till minnesadressen för en variabel, vilket möjliggör effektiv åtkomst och manipulering av datastrukturer.
Vad är en pekare?
I Go är en pekare en variabel som lagrar adressen till en annan variabel. Adressen är den unika minnesplatsen där variabeln lagras. Pekare skapas med operatorn `&`, som returnerar adressen till en variabel.
Låt oss till exempel säga att vi har en variabel `number` av typen `int`. Vi kan skapa en pekare till `nummer` med `&`-operatorn:
``` gå
nummer:=10
pekare :=&nummer
```
Variabeln `pekare` lagrar nu minnesadressen för variabeln `nummer`.
Från hänvisning till en pekare
För att komma åt värdet på en pekare kan vi använda operatorn `*`. Operatorn `*` refererar bort en pekare och returnerar värdet lagrat på minnesadressen som pekaren innehåller.
I vårt exempel kan vi referera bort variabeln `pekare` för att komma åt värdet för variabeln `nummer`:
``` gå
dereferencedNumber :=*pekare
```
Variabeln `dereferencedNumber` lagrar nu värdet för variabeln `number`, som är 10.
Pekararitmetik
Pekare kan också användas för att utföra pekaritmetik. Pekararitmetik är processen att lägga till eller subtrahera heltal från en pekare för att ändra minnesadressen som den refererar till.
Låt oss till exempel säga att vi har en array med heltal som kallas 'arr' och vi vill iterera genom elementen i arrayen. Vi kan använda operatorn `+` för att lägga till ett heltal till en pekare för att flytta till nästa element i arrayen:
``` gå
arr :=[5]int{1, 2, 3, 4, 5}
// Initiera en pekare till det första elementet i arrayen
pekare :=&arr[0]
// Iterera genom arrayen med hjälp av pekaritmetik
för i :=0; i
// Referera bort pekaren för att få värdet vid det aktuella indexet
värde :=*pekare
// Skriv ut värdet
fmt.Println(värde)
// Öka pekaren för att flytta till nästa element i arrayen
pekare++
}
```
I det här exemplet är "pekaren" initialt satt till adressen för det första elementet i arrayen. Sedan itererar `for`-slingan genom arrayen, avreferenser `pekaren` vid varje iteration för att få värdet på det aktuella elementet. "Pekaren" inkrementeras sedan för att flytta till nästa element i arrayen.
Visa pekare till funktioner
Pekare kan skickas som argument till funktioner. Detta tillåter funktioner att direkt manipulera minnesadressen för variabler, snarare än att skapa en kopia av variabeln.
Låt oss till exempel säga att vi har en funktion som heter "inkrement" som ökar värdet på ett heltal. Vi kan skicka en pekare till ett heltal som ett argument till funktionen "inkrementera", vilket tillåter funktionen att direkt modifiera värdet på heltal:
``` gå
func increment(ptr *int) {
// Referera bort pekaren för att få värdet på minnesadressen
värde :=*ptr
// Öka värdet
värde++
// Lagra det inkrementerade värdet tillbaka på minnesadressen
*ptr =värde
}
func main() {
// Skapa en heltalsvariabel
nummer:=10
// Skicka en pekare till variabeln som ett argument till inkrementfunktionen
öka (&nummer)
// Skriv ut det ökade värdet
fmt.Println(nummer) // Utdata:11
}
```
I det här exemplet tar funktionen "öka upp" en pekare till ett heltal som ett argument. Funktionen refererar bort pekaren för att få värdet på minnesadressen, ökar värdet,
