Aller aux pointeurs de langue

Les pointeurs en langage Go sont faciles à apprendre. L'utilisation de pointeurs en langage Go peut faciliter l'exécution de certaines tâches.

Apprenons ensuite les pointeurs du langage Go étape par étape.

Nous savons tous qu'une variable est un espace réservé pratique pour référencer une adresse mémoire d'ordinateur.

Le caractère d'adresse en langage Go est &. Lorsqu'il est utilisé devant une variable, l'adresse mémoire de la variable correspondante sera renvoyée.

L'exemple suivant montre l'adresse d'une variable en mémoire :

package main

import "fmt"

func main() {
   var a int = 10   

   fmt.Printf("变量的地址: %x\n", &a  )
}

Le résultat de l'exécution du code ci-dessus est :

变量的地址: 20818a220

Maintenant, nous avons compris ce qu'est une adresse mémoire est et comment y accéder. Nous présenterons ensuite les pointeurs en détail.

Qu'est-ce qu'un pointeur

Une variable pointeur peut pointer vers l'adresse mémoire de n'importe quelle valeur. Elle pointe vers l'adresse mémoire de cette valeur.

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

var var_name *var-type

var-type est le type du pointeur, var_name est le nom de la variable du pointeur et le signe * est utilisé pour spécifier que la variable est utilisée comme pointeur. Les déclarations de pointeur suivantes sont valides :

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

Dans ce cas, il s'agit d'un pointeur vers int et float32.

Comment utiliser les pointeurs

Processus d'utilisation du pointeur :

• Définir les variables du pointeur.

• Attribuez une valeur à une variable de pointeur.

• Accédez à la valeur pointant vers l'adresse dans la variable pointeur.

Ajoutez * (préfixe) devant le type de pointeur pour que le contenu pointe par le pointeur.

package main

import "fmt"

func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */

   fmt.Printf("a 变量的地址是: %x\n", &a  )

   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量的存储地址: %x\n", ip )

   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )
}

Le résultat d'exécution de l'exemple ci-dessus est :

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

Go pointeur nul

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

Le pointeur nul est également appelé pointeur nul.

nil est conceptuellement identique à null, None, nil et NULL dans d'autres langages, et ils font tous référence à des valeurs nulles ou vides.

Une variable pointeur est généralement abrégée ptr.

Voir l'exemple suivant :

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("ptr 的值为 : %x\n", ptr  )
}

Le résultat de sortie de l'exemple ci-dessus est :

ptr 的值为 : 0

Jugement de pointeur nul :

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

Go pointeur plus de contenu

Ensuite, nous vous présenterons davantage d'applications de pointeurs en langage Go :