Golang change le pointeur pointant

Golang est un langage de programmation open source efficace, évolutif et facile à apprendre. Il est largement utilisé dans les applications réseau, les systèmes distribués, le cloud computing, l'intelligence artificielle et d'autres domaines.

Dans Golang, le pointeur est un type de données très courant. Il est utilisé pour stocker l'adresse d'une variable en mémoire, permettant au programme d'accéder et de modifier directement la valeur de la variable. Les pointeurs dans Golang peuvent obtenir l'adresse d'une variable via l'opérateur & et accéder indirectement à la valeur de la variable à l'aide de l'opérateur *.

Cependant, dans certains cas, nous devrons peut-être changer le pointeur pointant de l'adresse d'une variable vers l'adresse d'une autre variable pendant l'exécution du programme. Cela se produit généralement dans les programmes qui impliquent des opérations de mémoire ou de structure de données allouées dynamiquement. Dans cet article, nous explorerons comment modifier le pointage du pointeur dans Golang.

Affectation de pointeurs

Tout d'abord, regardons un exemple simple pour montrer comment utiliser des pointeurs pour modifier la valeur d'une variable.

package main
  
import "fmt"
  
func main() {
    var a int = 10        // 声明一个变量a，并初始化为10
    var p *int           // 声明一个整型指针p
  
    p = &a               // 将指针p指向变量a的地址
    *p = 20              // 通过指针p，修改a的值为20
  
    fmt.Println("a = ", a) // 输出a的值，结果为20
}

Dans le code ci-dessus, nous déclarons une variable entière a et l'initialisons à 10. Dans le même temps, un pointeur p pointant sur un entier est déclaré et pointe vers l'adresse de la variable a via l'opérateur &. Ensuite, nous utilisons *p pour obtenir la valeur de la variable pointée par le pointeur p et la modifions à 20, changeant ainsi la valeur de la variable a.

Redirection des pointeurs

Dans l'exemple ci-dessus, nous avons modifié la valeur de la variable a via le pointeur p, mais n'avons pas changé le pointeur du pointeur p lui-même. Voyons maintenant comment rediriger un pointeur pour qu'il pointe vers l'adresse d'une autre variable.

package main
  
import "fmt"
  
func main() {
    var a int = 10        // 声明一个变量a，并初始化为10
    var b int = 20        // 声明一个变量b，并初始化为20
    var p *int           // 声明一个整型指针p
  
    p = &a               // 将指针p指向变量a的地址
    p = &b               // 将指针p重定向为变量b的地址
  
    fmt.Println("a = ", a) // 输出a的值，结果为10
    fmt.Println("b = ", b) // 输出b的值，结果为20
    fmt.Println("*p = ", *p) // 输出*p所指向变量的值，结果为20
}

Dans le code ci-dessus, nous avons déclaré deux variables entières a et b et les avons initialisées à 10 et 20 respectivement. Parallèlement, un pointeur p pointant sur un entier est déclaré. Ensuite, nous utilisons &p pour pointer le pointeur p vers l'adresse de la variable a, puis le redirigeons vers l'adresse de la variable b.

Lorsque nous extrayons les valeurs de a et b, nous constatons que leurs valeurs n'ont pas changé, et via *p nous pouvons accéder à la valeur de la variable b, qui est 20.

Échange de pointeurs

L'échange de pointeurs fait référence à l'échange des adresses de variables pointées par deux pointeurs pour atteindre l'objectif d'échange de valeurs de variable. Dans cette section, nous présenterons deux méthodes pour implémenter l'échange de pointeurs.

Méthode 1 : Échanger via des variables temporaires

package main
  
import "fmt"
  
func swap(a, b *int) {
    var temp int        // 定义一个临时变量temp
    temp = *a
    *a = *b
    *b = temp
}
  
func main() {
    var a int = 10        // 声明一个变量a，并初始化为10
    var b int = 20        // 声明一个变量b，并初始化为20
    var p1 *int = &a      // 声明一个指向变量a的指针p1
    var p2 *int = &b      // 声明一个指向变量b的指针p2
  
    swap(p1, p2)          // 交换指针p1和p2所指向变量的值
  
    fmt.Println("a = ", a) // 输出a的值，结果为20
    fmt.Println("b = ", b) // 输出b的值，结果为10
}

Dans le code ci-dessus, nous définissons une fonction d'échange qui accepte deux pointeurs vers le type int. Dans cette fonction, nous définissons une variable temporaire temp pour stocker la valeur de la variable pointée par l'un des pointeurs. Ensuite, on échange la valeur de la variable via le pointeur, et on réalise enfin l'échange de pointeurs.

Deuxième méthode : échange de pointeur à pointeur

package main
  
import "fmt"
  
func swap(a **int, b **int) {
    var temp *int         
    temp = *a
    *a = *b
    *b = temp
}
  
func main() {
    var a int = 10        // 声明一个变量a，并初始化为10
    var b int = 20        // 声明一个变量b，并初始化为20
    var p1 *int = &a      // 声明一个指向变量a的指针p1
    var p2 *int = &b      // 声明一个指向变量b的指针p2
  
    swap(&p1, &p2)        // 交换指针p1和p2的指向
  
    fmt.Println("a = ", a) // 输出a的值，结果为20
    fmt.Println("b = ", b) // 输出b的值，结果为10
}

Dans le code ci-dessus, nous avons modifié la signature de la fonction d'échange afin qu'elle accepte deux pointeurs vers des pointeurs. De cette façon, dans la fonction swap, on peut échanger le pointage de ces deux pointeurs, réalisant ainsi l'échange de pointeurs.

Résumé

Cet article présente principalement la méthode de changement du pointage du pointeur dans Golang. Grâce à l'explication de cet article, nous pouvons comprendre comment utiliser des pointeurs pour modifier la valeur d'une variable, rediriger le pointeur vers un point et échanger la valeur de la variable pointée par le pointeur.

Nous devons être très prudents lorsque nous utilisons des pointeurs, car une utilisation incorrecte des pointeurs peut provoquer des plantages du programme ou une corruption des données. Par conséquent, nous devons lire attentivement le code et toujours utiliser les pointeurs avec prudence.

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!