Pointers in Go er et kraftig verktøy for å administrere minne og manipulere data. De gir en måte å direkte referere til minneadressen til en variabel, noe som gir effektiv tilgang og manipulering av datastrukturer.
Hva er en peker?
I Go er en peker en variabel som lagrer adressen til en annen variabel. Adressen er den unike minneplasseringen der variabelen er lagret. Pekere lages ved å bruke `&`-operatoren, som returnerer adressen til en variabel.
La oss for eksempel si at vi har en variabel `antall` av typen `int`. Vi kan lage en peker til `nummer` ved å bruke `&`-operatoren:
``` gå
tall:=10
peker :=&nummer
```
`Peker`-variabelen lagrer nå minneadressen til `nummer`-variabelen.
Fjerne referanse til en peker
For å få tilgang til verdien av en peker, kan vi bruke `*`-operatoren. `*`-operatøren refererer til en peker, og returnerer verdien som er lagret på minneadressen som pekeren inneholder.
I vårt eksempel kan vi avreferere «peker»-variabelen for å få tilgang til verdien av «nummer»-variabelen:
``` gå
dereferencedNumber :=*peker
```
Variabelen «dereferencedNumber» lagrer nå verdien til «number»-variabelen, som er 10.
Pekeraritmetikk
Pekere kan også brukes til å utføre pekereritmetikk. Pekeraritmetikk er prosessen med å legge til eller trekke heltall fra en peker for å endre minneadressen den refererer til.
For eksempel, la oss si at vi har en rekke heltall kalt `arr` og vi ønsker å iterere gjennom elementene i matrisen. Vi kan bruke `+`-operatoren til å legge til et heltall til en peker for å flytte til neste element i matrisen:
``` gå
arr :=[5]int{1, 2, 3, 4, 5}
// Initialiser en peker til det første elementet i matrisen
peker :=&arr[0]
// Iterer gjennom matrisen ved å bruke pekeraritmetikk
for i :=0; i
// Referer pekeren for å få verdien ved gjeldende indeks
verdi :=*peker
// Skriv ut verdien
fmt.Println(verdi)
// Øk pekeren for å flytte til neste element i matrisen
peker++
}
```
I dette eksemplet er pekeren "pekeren" i utgangspunktet satt til adressen til det første elementet i matrisen. Deretter itererer 'for'-løkken gjennom matrisen, og refererer til 'pekeren' ved hver iterasjon for å få verdien til det gjeldende elementet. "Pekeren" økes deretter for å flytte til neste element i matrisen.
Videre pekere til funksjoner
Pekere kan sendes som argumenter til funksjoner. Dette lar funksjoner direkte manipulere minneadressen til variabler, i stedet for å lage en kopi av variabelen.
La oss for eksempel si at vi har en funksjon kalt "inkrement" som øker verdien av et heltall. Vi kan sende en peker til et heltall som et argument til «increment»-funksjonen, slik at funksjonen kan endre verdien av heltallet direkte:
``` gå
func increment(ptr *int) {
// Referer pekeren for å få verdien på minneadressen
verdi :=*ptr
// Øk verdien
verdi++
// Lagre den økte verdien tilbake på minneadressen
*ptr =verdi
}
func main() {
// Lag en heltallsvariabel
tall:=10
// Send en peker til variabelen som et argument til inkrementfunksjonen
økning (&tall)
// Skriv ut den økte verdien
fmt.Println(nummer) // Utdata:11
}
```
I dette eksemplet tar "inkrement"-funksjonen en peker til et heltall som et argument. Funksjonen derefererer pekeren for å få verdien på minneadressen, øker verdien,
