À propos de la compréhension du pointeur Golang

Ce qui suit est une introduction à la compréhension du pointeur Golang à partir de la colonne tutoriel Golang J'espère que cela sera utile aux amis dans le besoin !

0x00 Adresse du pointeur et type de pointeur

Une variable correspond à un espace mémoire qui stocke la valeur du type correspondant du variable et un pointeur La valeur est l'adresse d'une autre variable et la variable pointeur peut pointer vers l'adresse mémoire de n'importe quelle valeur.

Obtenir le symbole d'adresse&
Ajouter * avant le type du pointeur pour obtenir le contenu pointé par le pointeur. Il s'agit d'un changeur de type. L'utilisation d'un pointeur pour référencer une valeur est appelée citation d'indirection. .

prt := &v    // v 的类型为T

v représente la variable à récupérer prt reçoit l'adresse de v. Le type de prt est *T, qui est appelé le type de pointeur de T.

0x01 Récupérez la valeur pointée par le pointeur à partir du pointeur

Après avoir utilisé & pour obtenir l'adresse de la variable, pour obtenir le pointeur de la variable, vous pouvez utiliser * sur le numéro du pointeur pour obtenir la valeur pointée par ce pointeur, qui est appelée acquisition de la valeur du pointeur.

temp := "test content"
prt := &temp
fmt.Println(*prt)   // 打印 test content

Les relations et caractéristiques des variables, des adresses de pointeur, des variables de pointeur, des adresses et des valeurs sont les suivantes :

Effectuer l'opération d'adresse (&) sur une variable pour obtenir cette variable de pointeur variable.
La valeur d'une variable de pointeur est l'adresse du pointeur.
Effectuez l'opération valeur (*) sur la variable pointeur pour obtenir la valeur de la variable d'origine pointée par la variable pointeur.

0x02 Utilisez le pointeur pour modifier la valeur

Utilisez * pour modifier et utiliser la valeur pointée par le pointeur

x, y := 1, 2
fmt.Println(x, y)  // 1 2
j, k := &x, &y
*j, *k = *k, *j
fmt.Println(x, y)  // 2 1

* La signification fondamentale de l'opérateur est d'opérer la variable pointée par le pointeur. Lorsque l'opération porte sur une valeur r, elle prend la valeur de la variable pointée ; lorsque l'opération porte sur une valeur l, elle définit la valeur sur la variable pointée.

Si seul le pointeur de référence est échangé, la variable, la valeur et l'adresse référencées ne seront pas affectées, seul le pointeur d'application sera affecté.

x, y := 1, 2
fmt.Println(x, y)  // 1 2
j, k := &x, &y
j, k = k, j
fmt.Println(x, y)    // 1 2
fmt.Printf("x : %p, y :  %p \n", &x, &y)  // x : 0xc00001a088, y :  0xc00001a090
fmt.Printf("j : %p, y :  %p \n", j, k)  //j : 0xc00001a090, y :  0xc00001a088

Les valeurs et adresses de x et y ne sont pas affectées. Une fois les pointeurs j et k échangés, les valeurs de j et k sont échangées.

0x03 Renvoie les variables locales dans la fonction

En langage Go, il est également sûr de renvoyer l'adresse des variables locales dans la fonction. Par exemple, dans le code suivant, appelez f La variable locale v est créée pendant la fonction et est toujours valide après le retour de l'adresse de la variable locale, car le pointeur p fait toujours référence à cette variable

var p = f()

func f() *int {
    v := 1
    return &v
}

0x04 Utilisez new() pour créer le pointeur

	temp := new(int)
	*temp = 123
	fmt.Println(*temp)  // 123
	fmt.Println(temp)  //  0xaabb

0x05 Technologie de pointeur du package flag

le pointeur est la technologie clé pour implémenter le package flag dans la norme bibliothèque. Il est utilisé pour implémenter l’analyse des indicateurs de ligne de commande.
Exemple :

package main

import (
    "flag"
    "fmt"
    "strings"
)

var n = flag.Bool("n", true, "print test")
var sep = flag.String("s", " ", "separator")
var test = flag.String("test", " ", "测试")

func main() {
    flag.Parse()
    fmt.Println(strings.Join(flag.Args(), *sep))
    if *n {
        fmt.Println(*test)
    }
}

Exécuter

$ go run main.go --help
Usage of /var/exe/main:
  -n	print test
  -s string
    	separator (default " ")
  -test string
    	测试 (default " ")
exit status 2
$ go run main.go -s "+"  --test 测试文本 a bc def 123
a+bc+def+123
$ go run main.go -s "+" -n --test 测试文本 a bc def 123
a+bc+def+123
测试文本

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!