| Pointers in Go zijn een krachtig hulpmiddel voor het beheren van geheugen en het manipuleren van gegevens. Ze bieden een manier om rechtstreeks naar het geheugenadres van een variabele te verwijzen, waardoor efficiënte toegang tot en manipulatie van datastructuren mogelijk is.
Wat is een aanwijzer?
In Go is een pointer een variabele die het adres van een andere variabele opslaat. Het adres is de unieke geheugenlocatie waar de variabele is opgeslagen. Pointers worden gemaakt met behulp van de `&` operator, die het adres van een variabele retourneert.
Laten we bijvoorbeeld zeggen dat we een variabele `number` van het type `int` hebben. We kunnen een verwijzing naar `nummer` maken met behulp van de `&` operator:
```gaan
aantal :=10
aanwijzer :=&nummer
```
De `pointer`-variabele slaat nu het geheugenadres van de `number`-variabele op.
De verwijzing naar een aanwijzer ongedaan maken
Om toegang te krijgen tot de waarde van een pointer, kunnen we de operator `*` gebruiken. De `*`-operator herleidt de verwijzingen naar een pointer en retourneert de waarde die is opgeslagen op het geheugenadres dat de pointer bevat.
In ons voorbeeld kunnen we de referentievariabele `pointer` derefereren om toegang te krijgen tot de waarde van de variabele `number`:
```gaan
dereferencedNumber :=*aanwijzer
```
De variabele `dereferencedNumber` slaat nu de waarde op van de variabele `number`, namelijk 10.
Aanwijzerberekeningen
Pointers kunnen ook worden gebruikt om pointer-berekeningen uit te voeren. Pointer-rekenkunde is het proces waarbij gehele getallen worden opgeteld of afgetrokken van een pointer om het geheugenadres waarnaar deze verwijst te wijzigen.
Laten we bijvoorbeeld zeggen dat we een array van gehele getallen hebben genaamd `arr` en dat we de elementen van de array willen doorlopen. We kunnen de operator `+` gebruiken om een geheel getal toe te voegen aan een pointer om naar het volgende element van de array te gaan:
```gaan
arr :=[5]int{1, 2, 3, 4, 5}
// Initialiseer een pointer naar het eerste element van de array
aanwijzer :=&arr[0]
// Doorloop de array met behulp van pointer-berekeningen
voor ik :=0; ik
// Derefereer de aanwijzer om de waarde bij de huidige index te krijgen
waarde :=*aanwijzer
// Druk de waarde af
fmt.Println(waarde)
// Verhoog de aanwijzer om naar het volgende element van de array te gaan
aanwijzer++
}
```
In dit voorbeeld wordt de pointer "pointer" aanvankelijk ingesteld op het adres van het eerste element van de array. Vervolgens itereert de 'for'-lus door de array, waarbij bij elke iteratie de verwijzing naar de 'pointer' wordt verwijderd om de waarde van het huidige element te verkrijgen. De 'pointer' wordt vervolgens verhoogd om naar het volgende element van de array te gaan.
Aanwijzingen doorgeven aan functies
Pointers kunnen als argumenten aan functies worden doorgegeven. Hierdoor kunnen functies het geheugenadres van variabelen rechtstreeks manipuleren, in plaats van een kopie van de variabele te maken.
Laten we bijvoorbeeld zeggen dat we een functie hebben genaamd 'increment' die de waarde van een geheel getal verhoogt. We kunnen een verwijzing naar een geheel getal doorgeven als argument voor de functie 'increment', waardoor de functie de waarde van het gehele getal direct kan wijzigen:
```gaan
func verhoging(ptr *int) {
// Derefereer de aanwijzer om de waarde op het geheugenadres te krijgen
waarde :=*ptr
// Verhoog de waarde
waarde++
// Bewaar de verhoogde waarde terug op het geheugenadres
*ptr =waarde
}
func hoofd() {
// Maak een integer-variabele
aantal :=10
// Geef een pointer naar de variabele door als argument voor de increment-functie
verhoging(&getal)
// Druk de verhoogde waarde af
fmt.Println(getal) // Uitvoer:11
}
```
In dit voorbeeld neemt de functie `increment` een verwijzing naar een geheel getal als argument. De functie herleidt de verwijzing naar de waarde op het geheugenadres, verhoogt de waarde, |
