slices pointer make golang array pointers go

pointers - pointer - ¿Cómo funciona la desreferenciación de punteros en golang?



make in go (1)

Estoy repasando los tutoriales de golang en http://tour.golang.org/ , y estaba experimentando un poco con algunas cosas en el ejemplo 29

Para su referencia, el ejemplo original se copia aquí:

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() { fmt.Println(p, q, r, s) }

Es bastante básico, que muestra cómo crear instancias de esta estructura nueva y elegante, Vertex . El ejemplo 28 , sin embargo, muestra la manipulación de un vértice a través de un puntero al mismo, así que modifiqué un poco el ejemplo y me sorprendió la salida. Aquí está la modificación:

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

Y el resultado:

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

Lo que me sorprendió es que t no es {4, 2}, lo que parece significar que cambiar qX cambió la instancia de la estructura a la que q apuntaba. Viniendo de un fondo de C / C ++, esto me parece un comportamiento extremadamente extraño.

Entonces, ¿qué está pasando realmente aquí? ¿Por qué usar qX = 4 para cambiar el vértice no se propaga a t ?


t := *q hace una copia de la estructura apuntada por q .

Si desea observar cambios en q través de t , entonces quédese con un puntero:

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

Esto produce la salida que probablemente estabas buscando.

{1 2} &{4 2} {1 0} {0 0} &{4 2} {4 2} true

No estoy seguro de lo que te parece extremadamente extraño. C y C ++ se comportan de la misma manera. Considera lo siguiente:

#include <iostream> struct Vertex { int x; int y; }; std::ostream& operator<<(std::ostream& out, const Vertex& v) { out << "{ " << v.x << ", " << v.y << " }"; return out; } 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"; }

El resultado de este código C ++ muestra el mismo comportamiento:

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