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 }