Les pointeurs
C'est quoi un pointeur?
Un pointeur est une variable qui stocke l'adresse mémoire d'une autre variable.
La déclaration des pointeurs
*T est le type de la variable pointeur qui pointe sur une valeur de type T.
package main
import (
"fmt"
)
func main() {
b := 255
var a *int = &b
fmt.Printf("Type de a est %T\n", a)
fmt.Println("addresse de b est", a)
}
L'opérateur & est utlisé pour avoir l'adresse de la variable. Dans le programme ci-dessus, on a attribué à a(de type int) l'adresse de b (a pointe sur b). Quand on affiche la valeur de a, l'adresse de b serait affichée. Voici la sortie du programme:
Type de a est *int
addresse de b est 0x1040a124
l'adresse de b peut être différente puisque b peut être à n'importe quel emplacement dans la mémoire.
La valeur zéro d'un pointeur
la valeur zéro d'un pointeur est nil.
package main
import (
"fmt"
)
func main() {
a := 25
var b *int
if b == nil {
fmt.Println("b is", b)
b = &a
fmt.Println("b après initialisation", b)
}
}
b est initialisé à nil puis on lui attribue l'adresse de a. Voici la sortie du programme ci-dessus:
b is <nil>
b après initialisation is 0x1040a124
La déréférence d'un pointeur veut dire l'accès à une valeur de la variable sur la quelle le pointeur pointe. *a est le syntaxe pour déréférencer a.
package main
import (
"fmt"
)
func main() {
b := 255
a := &b
fmt.Println("addresse de b est", a)
fmt.Println("valeur de b est", *a)
}
Après l'exécution du programme, on obtient:
addresse de b est 0x1040a124
valeur de b est 255
On écrit un programme où on change la valeur de b en utilisant le pointeur.
package main
import (
"fmt"
)
func main() {
b := 255
a := &b
fmt.Println("addresse de b est", a)
fmt.Println("valeur de b est", *a)
*a++
fmt.Println("nouvelle valeur de b est", b)
}
Dans le programme ci-dessus, on incrémente la valeur pointée par a qui change la valeur de b puisque a pointe sur b. Par conséquent, la valeur de b devient 256. La sortie du programme est:
addresse de b est 0x1040a124
valeur de b est 255
nouvelle valeur de b est 256
Passer un pointeur à une fonction
package main
import (
"fmt"
)
func change(val *int) {
*val = 55
}
func main() {
a := 58
fmt.Println("valeur de a avant l'appel de la fonction est",a)
b := &a
change(b)
fmt.Println("valeur de a après l'appel de la fonction est", a)
}
Dans le programme ci-dessus, on passe à la fonction change une variable pointeur b qui contient l'adresse de a . À l'intérieur de la fonction change, la valeur de a est changée en utilisant la déréférence, voici la sortie du programme,
valeur de a avant l'appel de la fonction est 58
valeur de a après l'appel de la fonction est 55
Il ne faut pas passer à une fonction un pointeur sur un tableau comme paramètre
Supposons qu'on veut effectuer des modifications sur un tableau dans une fonction et qu'on veut que ces modifications soient visibles après l'appel de la fonction, pour ce faire, on passe à la fonction comme argument un pointeur sur un tableau.
package main
import (
"fmt"
)
func modify(arr *[3]int) {
(*arr)[0] = 90
}
func main() {
a := [3]int{89, 90, 91}
modify(&a)
fmt.Println(a)
}
Dans le programme ci-dessus, on passe à la fonction modify l'adresse de a . La sortie du programme est [90 90 91].
a[x] est une manière abrégée pour écrire (*a)[x].
Il existe une manière plus pratique pour faire cette modification en utilisant les tranches.
package main
import (
"fmt"
)
func modify(sls []int) {
sls[0] = 90
}
func main() {
a := [3]int{89, 90, 91}
modify(a[:])
fmt.Println(a)
}
Dans le programme ci-dessus, on passe à la fonction modify une tranche. Le premier élément de la tranche est changé à l'intérieur de la fonction modify en 90. La sortie du programme est [90 90 91].
Les pointeurs arithmétiques ne sont pas disponibles en Go
package main
func main() {
b := [...]int{109, 110, 111}
p := &b
p++
}
Le programme va lancer une erreur de compilation main.go:6: invalid operation: p++ (non-numeric type *[3]int).
Posted on Utopian.io - Rewarding Open Source Contributors