Pointeurs en langage Go

Les pointeurs en Go sont faciles à apprendre, et l'utilisation des pointeurs en Go peut rendre certaines tâches plus simples.

Ensuite, apprenons les pointeurs Go étape par étape.

Nous savons tous qu'une variable est un espace réservé pratique servant à référencer une adresse mémoire de l'ordinateur.

L'opérateur d'adressage en Go est &, et lorsqu'il est placé devant une variable, il renvoie l'adresse mémoire de cette variable.

L'exemple suivant montre l'adresse des variables en mémoire :

Exemple

package main

import "fmt"

func main() {
var a int = 10

fmt.Printf("Adresse de la variable : %x\n"\n", &a )
}

La sortie de l'exécution du code ci-dessus est :

变量的地址: 20818a220

Maintenant, nous avons compris ce que sont les adresses mémoire et comment y accéder. Ensuite, nous allons présenter les pointeurs en détail.

Qu'est-ce qu'un pointeur

Une variable pointeur pointe vers l'adresse mémoire d'une valeur.

Comme pour les variables et les constantes, vous devez déclarer un pointeur avant de l'utiliser. Le format de déclaration d'un pointeur est le suivant :

var var_name *var-type

var-type est le type du pointeur, var_name est le nom de la variable pointeur, et le signe * est utilisé pour spécifier que la variable est un pointeur. Voici des déclarations de pointeur valides :

var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */

Dans cet exemple, il s'agit d'un pointeur vers int et float32.

Comment utiliser les pointeurs

Processus d'utilisation des pointeurs :

Définir une variable pointeur.
Attribuer une valeur à la variable pointeur.
Accéder à la valeur à l'adresse pointée par la variable pointeur.

Ajoutez le signe * (préfixe) avant le type pointeur pour obtenir le contenu pointé par le pointeur.

Exemple

package main

import "fmt"

func main() {
var a int= 20 /* Déclarer une variable réelle */
var ip *int /* Déclarer une variable pointeur */

ip = &a /* L'adresse stockée dans la variable pointeur */

fmt.Printf("L'adresse de la variable a est : %x\n\n", &a )

/* L'adresse stockée dans la variable pointeur */
fmt.Printf("Adresse du pointeur stockée dans la variable ip : %x\n\n", ip )

/* Utiliser le pointeur pour accéder à la valeur */
fmt.Printf("Valeur de la variable *ip : %d\n\n", *ip )
}

La sortie de l'exemple ci-dessus est :

a 变量的地址是: 20818a220
ip 变量储存的指针地址: 20818a220
*ip 变量的值: 20

Pointeur nul en Go

Lorsqu'un pointeur est défini mais n'est affecté à aucune variable, sa valeur est nil.

Un pointeur nil est aussi appelé un pointeur nul.

Conceptuellement, nil est identique à null, None, nil et NULL dans d'autres langages, tous désignant des valeurs zéro ou des valeurs vides.

Une variable pointeur est souvent abrégée en ptr.

Voir l'exemple suivant :

Exemple

package main

import "fmt"

func main() {
var ptr *int

fmt.Printf(La valeur de ptr est : %x\n", ptr )
}

La sortie de l'exemple ci-dessus est :

ptr 的值为 : 0

Vérification de pointeur nul :

if(ptr != nil)     /* ptr 不是空指针 */
if(ptr == nil)    /* ptr 是空指针 */

Plus d'informations sur les pointeurs Go

Ensuite, nous présenterons davantage d'applications des pointeurs en Go :

content	Description
Tableau de pointeurs en Go	Vous pouvez définir un tableau de pointeurs pour stocker des adresses.
Pointeur vers pointeur en Go	Go prend en charge les pointeurs vers des pointeurs.
Passage de paramètres pointeurs à des fonctions en Go	En passant des paramètres par référence ou par adresse, vous pouvez modifier leurs valeurs lors des appels de fonction.

autres extensions