Comment les pointeurs sont-ils utilisés dans le langage Go ?

Le langage Go est un langage sûr et efficace. Il fournit des pointeurs comme type de données, permettant aux programmeurs de contrôler plus complètement l'utilisation de la mémoire. Les pointeurs sont une fonctionnalité importante du langage Go, et maîtriser leur utilisation est un cours obligatoire pour tout développeur Go. Cet article explique comment utiliser les pointeurs en langage Go.

Que sont les pointeurs ?

En termes simples, un pointeur est une variable qui pointe vers une adresse mémoire. Pour une variable, nous pouvons utiliser l'opérateur & pour obtenir son adresse mémoire, et la variable pointeur est la variable qui stocke cette adresse mémoire. Grâce à des pointeurs, nous pouvons accéder directement à la valeur dans l'adresse mémoire correspondante et modifier cette valeur. Il s’agit de la fonctionnalité la plus élémentaire qu’un pointeur puisse fournir.

Déclaration de pointeurs

En langage Go, la déclaration d'un pointeur doit être marquée de l'opérateur *. Par exemple :

var ptr *int   // 声明一个指向int型变量的指针

Une variable ptr est déclarée ici, qui est un pointeur entier. C'est-à-dire que ptr stocke l'adresse mémoire d'une variable entière.

Fonctionnement des pointeurs

Les opérations de base des pointeurs incluent l'obtention d'adresses, la conversion de types, l'obtention de valeurs, etc.

Obtenir l'adresse

Utilisez l'opérateur & pour obtenir l'adresse mémoire d'une variable, par exemple :

var a int = 10
var ptr *int // 声明一个指向int型变量的指针
ptr = &a     // ptr指向a变量的内存地址

Ici, l'adresse de la variable a est stockée dans la variable de pointeur ptr.

Type de conversion

Les variables de pointeur peuvent être converties en type, ce qui est très utile lors du passage de paramètres de fonction ou de toute autre opération nécessitant une conversion de type.

Par exemple :

var a int = 20
var ip *int
ip = &a

fmt.Printf("变量a的地址为：%x
", &a)
// 指针变量中存储的地址
fmt.Printf("ip 变量存储的地址：%x
", ip )
// 使用指针访问值
fmt.Printf("*ip 变量的值：%d
", *ip )

Dans le code ci-dessus, il montre une fois de plus l'obtention de l'adresse de la variable, le pointage du pointeur IP vers l'adresse de a, puis l'accès à la valeur de la variable a via l'opérateur *ip.

Valeur

Grâce à l'opérateur *, nous pouvons obtenir la valeur stockée dans l'adresse mémoire pointée par le pointeur.

Par exemple :

var a int = 20   // 声明一个int型变量a
var ip *int      // 声明一个int型指针变量ip
ip = &a          // 取a的地址，将地址存储到ip中
fmt.Printf("a 变量的地址是：%x
", &a ) // 输出a的地址
fmt.Printf("ip 变量存储的地址是：%x
", ip ) // 输出ip变量中存储的地址
fmt.Printf("*ip 变量的值是：%d
", *ip ) // 输出ip变量中存储的值

Pointeur nul

Dans les applications réelles, il est parfois impossible de déterminer la valeur initiale pointée par le pointeur. Dans ce cas, le pointeur nul par défaut doit être utilisé.

Dans le langage Go, le pointeur nul par défaut est représenté par le mot-clé nil. Le pointeur nil est également appelé pointeur nul. Par exemple :

var ptr *int    // 声明一个指向int型变量的指针，未赋初值
if ptr == nil {
    fmt.Printf("ptr是空指针
")
}

Dans le code, la variable pointeur ptr est déclarée, mais aucune valeur n'est attribuée et sa valeur est nulle. À ce stade, en comparant avec nil, vous pouvez déterminer si la variable de pointeur ptr est un pointeur nul.

Application des pointeurs

Les pointeurs sont largement utilisés dans divers scénarios en langage Go. Ci-dessous, plusieurs scénarios d'application courants seront présentés.

Passer des paramètres de pointeur

Passer des pointeurs en tant que paramètres dans les appels de fonction peut transmettre l'adresse de la variable à la fonction appelante de cette manière, modifier la valeur dans la mémoire pointée par le pointeur dans la fonction affectera directement la valeur à l'extérieur. la fonction.

Par exemple :

func swap (x *int, y *int) {
   var temp int
   temp = *x    // 保存x地址上的值
   *x = *y      // 将y赋值给x地址上的值
   *y = temp    // 将原来x的值赋值给y地址上的值
}

func main() {
   // 声明两个变量
   var a int = 100
   var b int = 200

   fmt.Printf("交换前，a 的值为：%d
", a )
   fmt.Printf("交换前，b 的值为：%d
", b )

   // 调用swap()函数交换值
   swap(&a, &b)

   fmt.Printf("交换后，a 的值为：%d
", a )
   fmt.Printf("交换后，b 的值为：%d
", b )
}

Dans la fonction swap, un pointeur est utilisé pour recevoir les deux paramètres transmis, et l'opérateur * est utilisé pour obtenir la valeur dans la mémoire pointée par le pointeur. Après l'échange, la valeur. est réaffecté. Dans l'appel de fonction, transmettez les adresses de &a et &b, afin que les modifications à l'intérieur de la fonction affectent directement les valeurs des variables a et b dans la fonction principale.

Retour de pointeurs

Le retour de pointeurs dans des fonctions est également un scénario d'application très courant. Tout comme renvoyer une valeur ordinaire, une fonction qui renvoie un pointeur peut renvoyer directement l'adresse d'un pointeur quelque part dans le programme. Par exemple :

func getPtr() *int {
    i := 1
    return &i
}

func main() {
    p := getPtr()
    fmt.Println(*p)
}

Dans la fonction getPtr, une variable entière i est déclarée, utilisez l'opérateur & pour obtenir l'adresse de i et renvoie cette adresse. Ensuite, dans l’appel du programme, attribuez la valeur de retour à la variable de pointeur p, puis accédez à la valeur de i via *p.

Tableau de pointeurs

Différent des tableaux de variables ordinaires, les tableaux de pointeurs stockent les variables de pointeur. Grâce à l'index du tableau, vous pouvez accéder à la variable de pointeur correspondante, puis utiliser l'opérateur * pour obtenir la valeur pointant vers l'adresse mémoire.

Par exemple :

func main() {
    a := 1
    b := 2
    c := 3

    ptrArr := [...]*int{&a, &b, &c}
    for _, ptr := range ptrArr {
        fmt.Println(*ptr)
    }
}

Dans le code, trois variables entières a, b, c sont déclarées, puis le tableau de pointeurs ptrArr est déclaré à l'aide de... pour représenter la longueur incertaine du tableau. L'adresse de la variable. Dans le programme, le tableau de pointeurs est bouclé et chaque élément du tableau est utilisé comme variable de pointeur pour obtenir la valeur dans l'adresse correspondante.

Résumé

Cet article présente principalement les concepts de base et l'utilisation des pointeurs dans le langage Go. Maîtriser l'utilisation des pointeurs peut aider les développeurs à mieux contrôler l'utilisation de la mémoire et à améliorer les performances et l'efficacité des programmes. Dans les projets réels, les pointeurs sont utilisés dans un large éventail de scénarios. Les développeurs peuvent utiliser des pointeurs dans des scénarios appropriés en fonction des besoins du projet. Bien que l'utilisation de pointeurs comporte certains risques, tant que vous suivez les principes de sécurité des données et d'utilisation standardisée, vous pouvez jouer le rôle de pointeurs et écrire du code plus efficacement.

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!