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

---