Pourquoi le déréférencement d'un pointeur dans Go ne modifie-t-il pas la valeur d'origine ?

Déréférencement de pointeur dans Go : que se passe-t-il ?

En plongeant dans le monde de la programmation dans Go, vous pouvez rencontrer un comportement intrigant lié au déréférencement de pointeur, en particulier lorsque travailler avec des structures. Prenons l'exemple suivant :

package main

import "fmt"

type Vertex struct {
    X, Y int
}

var (
    p = Vertex{1, 2}  // has type Vertex
    q = &Vertex{1, 2} // has type *Vertex
    r = Vertex{X: 1}  // Y:0 is implicit
    s = Vertex{}      // X:0 and Y:0
)

func main() {
    t := *q
    q.X = 4
    u := *q
    fmt.Println(p, q, r, s, t, u, t == u)
}

L'exécution de ce code produit des résultats surprenants :

{1 2} &{4 2} {1 0} {0 0} {1 2} {4 2} false

Vous pourriez vous attendre à ce que t passe à {4, 2} après avoir modifié q.X, mais ce n'est pas le cas arriver. Quelle est la raison de ce comportement ?

Explication du déréférencement du pointeur

La clé pour comprendre cela est le déréférencement du pointeur. Dans Go, lorsque vous déréférencez un pointeur (par exemple, *q), vous créez une copie de la valeur vers laquelle il pointe. Ainsi, t := *q crée une copie séparée de la structure Vertex référencée par q.

Modification de l'exemple 28 clarifiée :

Dans votre exemple modifié, lorsque vous définissez q.X = 4, vous modifiez uniquement la structure pointée par q. Puisque t est une copie, il conserve ses valeurs d'origine.

Comparaison de Go et C/C

Vous avez mentionné le comportement qui semble étrange d'un point de vue C/C. Cependant, C/C se comportent de la même manière. Prenons cet exemple :

#include <iostream>

struct Vertex
{
    int x;
    int y;
};

int main()
{
    Vertex v = Vertex{1, 2};
    Vertex* q = &v;
    Vertex t = *q;
    q->x = 4;
    std::cout << "*q: " << *q << "\n";
    std::cout << " t: " << t << "\n";
}

Ce code C produit le même comportement :

*q: { 4, 2 }
t: { 1, 2 }

Conclusion

En résumé, lorsque vous déréférencez un pointeur dans Go, vous' re créer une copie de la valeur sous-jacente. Pour observer les modifications apportées via un pointeur, vous devez utiliser un pointeur lui-même, comme dans l'exemple modifié :

func main() {
    t := q
    q.X = 4
    u := *q
    fmt.Println(p, q, r, s, t, u, *t == u)
}

Cela produira le résultat attendu de {1 2} &{4 2} {1 0} {0 0} {4 2} {4 2} vrai.

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!