Pointeurs de Golang

Un pointeur dans la programmation fait référence à la variable utilisée pour stocker l'adresse mémoire d'une autre variable dans le système. L'adresse mémoire de la variable est exprimée au format hexadécimal en commençant par 0x.

Les pointeurs sont utiles car ils nous permettent de stocker la mémoire d'une adresse où les données détenues par une variable sont stockées. En utilisant des pointeurs, nous déterminons la valeur stockée par la variable à cette adresse mémoire.

Dans cet article pour les débutants, nous discuterons de la façon de commencer avec les pointeurs dans le langage de programmation Go.

Golang Declare Variable

Nous déclarons un pointeur de la même manière que nous déclarons une variable normale. Cependant, nous utilisons l'opérateur de déréférence pour montrer que la variable contient un pointeur.

Avant de déclarer une variable, il y a deux opérateurs que nous devons connaître:

1. * - La déclaration d'astérisque dans le pointeur est connue sous le nom d'opérateur de déréférence. Il est utilisé pour déclarer une valeur de pointeur et accéder à la valeur stockée à une adresse mémoire spécifique.
2. & - Dans Pointer, l'opérateur d'adresse est utilisé pour accéder à l'adresse mémoire d'une variable. Il peut également retourner l'adresse de la variable.

La syntaxe ci-dessous montre comment déclarer une variable de pointeur:

var pointer_name * data_type

Par exemple, le code ci-dessous déclare une variable de pointeur «PTR» qui contient l'adresse des types int.

var ptr * int

Golang Initialize Pointer

Nous pouvons initialiser un pointeur en allouant l'adresse mémoire d'une variable à l'aide de l'opérateur d'adresse, illustré ci-dessus.

Un exemple est comme indiqué:

package principal
Importer "FMT"
func main ()
// Déclarer la variable
x: = 100
// déclarer et initialiser le pointeur
var ptr * int = & x
// Adresse d'impression
fmt.Println (ptr)

Dans l'exemple ci-dessus, nous commençons par déclarer une variable contenant une valeur entière. Nous créons ensuite un pointeur tenant l'adresse mémoire de la variable.

Une fois que nous avons imprimé l'adresse, nous devons obtenir un exemple de sortie comme indiqué:

$ go run pointer.aller
0xc000018098

Nous pouvons également déclarer une variable et définir la valeur plus tard dans le code. Un exemple est comme indiqué:

package principal
Importer "FMT"
func main ()
// Déclarer la variable
x: = 100
// déclarer
var ptr * int
ptr = & x
// Adresse d'impression
fmt.Println (ptr)

Ici, nous déclarons le pointeur et définissons plus tard sa valeur à l'aide de l'opérateur d'adresse.

Pointeur de Golang Nil

Si vous déclarez un pointeur et n'attribuez pas de valeur, le pointeur contient une valeur nulle. Par exemple:

package principal
Importer "FMT"
func main ()
var ptr * int
fmt.Println (ptr)

Le code ci-dessus renvoie nil.

Type de pointeur

Dans notre exemple, nous avons déclaré le type du pointeur. Cela signifie que le pointeur ne peut maintenir que la mémoire adressée du type de données spécifié.

Si vous essayez de stocker l'adresse d'un autre type, le compilateur renvoie une erreur comme indiqué dans l'exemple ci-dessous:

package principal
Importer "FMT"
func main ()
// Déclarer la variable
str: = "bonjour"
var ptr * int
ptr = & str
// Adresse d'impression
fmt.Println (ptr)

Dans l'exemple ci-dessus, nous déclarons une variable avec type int. Cependant, nous attribuons une adresse d'un type de chaîne.

Le compilateur renvoie une erreur comme:

.\aiguille.GO: 11: 6: Impossible d'utiliser et Str (type * String) comme type * int en affectation

Pour éviter cela, vous pouvez utiliser la méthode de déclaration littérale du pointeur. Par exemple, nous pouvons faire:

package principal
Importer "FMT"
func main ()
str: = "bonjour"
ptr: = & str
fmt.Println (ptr)

L'exemple ci-dessus permet au compilateur de déterminer le type d'adresse à maintenir dans le pointeur spécifié.

Dereference du pointeur de Golang

Pour accéder à la valeur stockée à une adresse spécifique, nous pouvons utiliser l'opérateur de déréférence. Un exemple de code est comme indiqué:

package principal
Importer "FMT"
func main ()
x: = 100
ptr: = & x
fmt.Println ("x:", x)
fmt.Println ("Adresse:", PTR)
fmt.Println ("valeur à l'adresse:", * ptr)

Le code ci-dessus utilise l'opérateur de déréférence pour obtenir la valeur stockée à l'adresse détenue par le pointeur «PTR»

La sortie résultante est comme:

X: 100
Adresse: 0xc000018098
Valeur à l'adresse: 100

Conclusion

Ce guide vous guide à travers les bases de travailler avec des pointeurs dans Go. À l'aide de pointeurs, vous pouvez accéder et stocker l'adresse mémoire d'une variable. Vous pouvez également utiliser le pointeur pour accéder à la variable stockée à une adresse mémoire spécifique.

Merci d'avoir lu!