Como muchos otros lenguajes, Go tiene punteros.
Si eres nuevo en el uso de punteros, pueden parecer un poco misteriosos, pero una vez que te acostumbras a ellos, son bastante sencillos.
Son una parte crucial de Go, así que tómate un tiempo para entenderlos de verdad.
Antes de profundizar en los detalles, conviene entender el uso de los punteros.
Los punteros son una forma de compartir memoria con otras partes de nuestro programa, lo cual es útil por dos razones principales:
- Cuando tenemos grandes cantidades de datos, hacer copias para pasarlas entre funciones es muy ineficiente.
Al pasar en su lugar la ubicación de memoria donde se almacenan los datos, podemos reducir drásticamente el consumo de recursos de nuestros programas.
- Al pasar punteros entre funciones, podemos acceder y modificar directamente la única copia de los datos, lo que significa que cualquier cambio realizado por una función es visible de inmediato para otras partes del programa cuando la función termina.
Variables y memoria
Supongamos que tenemos una variable entera normal a:
var a int
Cuando declaramos una variable, Go tiene que encontrar un lugar en la memoria para almacenar su valor.
Esto está en gran medida abstraído de nosotros: cuando necesitamos obtener el valor almacenado en esa parte de la memoria, podemos referirnos a él simplemente por el nombre de la variable.
Por ejemplo, cuando escribimos a + 2, en realidad estamos obteniendo el valor almacenado en la memoria asociada a la variable a y sumándole 2.
De forma similar, cuando necesitamos cambiar el valor en la parte de memoria de a, podemos usar el nombre de la variable para hacer una asignación:
a = 3
La parte de memoria asociada a a ahora almacenará el valor 3.
Punteros
Aunque las variables nos permiten referirnos a valores en memoria, a veces es útil conocer la dirección de memoria a la que apunta la variable. Los punteros contienen las direcciones de memoria de esos valores.
Declaras una variable con un tipo puntero anteponiendo un asterisco al tipo subyacente:
var p *int // 'p' contains the memory address of an integer
Aquí declaramos una variable p de tipo «puntero a int» (*int).
Esto significa que p contendrá la dirección de memoria de un entero.
El valor cero de los punteros es nil porque un puntero nil no contiene ninguna dirección de memoria.
Obtener un puntero a una variable
Para encontrar la dirección de memoria del valor de una variable, podemos usar el operador &.
Por ejemplo, si queremos encontrar y almacenar la dirección de memoria de la variable a en el puntero p, podemos hacer lo siguiente:
var a int
a = 2
var p *int
p = &a // the variable 'p' contains the memory address of 'a'
Acceder al valor a través de un puntero (desreferenciación)
Cuando tenemos un puntero, puede que queramos conocer el valor almacenado en la dirección de memoria que representa el puntero.
Podemos hacerlo usando el operador *:
var a int
a = 2
var p *int
p = &a // the variable 'p' contains the memory address of 'a'
var b int
b = *p // b == 2
La operación *p obtiene el valor almacenado en la dirección de memoria que contiene p.
Esta operación suele llamarse «desreferenciación».
También podemos usar el operador de desreferencia para asignar un nuevo valor a la dirección de memoria a la que hace referencia el puntero:
var a int // declare int variable 'a'
a = 2 // assign 'a' the value of 2
var pa *int
pa = &a // 'pa' now contains to the memory address of 'a'
*pa = *pa + 2 // increment by 2 the value at memory address 'pa'
fmt.Println(a) // Output: 4
// 'a' will have the new value that was changed via the pointer!
Asignar a *pa cambiará el valor almacenado en la dirección de memoria que contiene pa.
Como pa contiene la dirección de memoria de a, al asignar a *pa estamos cambiando el valor de a.
No obstante, una advertencia: comprueba siempre que un puntero no sea nil antes de desreferenciarlo.
Desreferenciar un puntero nil hará que el programa se bloquee en tiempo de ejecución.
var p *int // p is nil initially
fmt.Println(*p)
// panic: runtime error: invalid memory address or nil pointer dereference
Punteros a estructuras
Hasta ahora solo hemos visto punteros a valores primitivos.
También podemos crear punteros para estructuras:
type Person struct {
Name string
Age int
}
var peter Person
peter = Person{Name: "Peter", Age: 22}
var p *Person
p = &peter
También podríamos haber creado un nuevo Person y almacenado inmediatamente un puntero a él:
var p *Person
p = &Person{Name: "Peter", Age: 22}
Cuando tenemos un puntero a una estructura, no necesitamos desreferenciar el puntero antes de acceder a uno de los campos:
var p *Person
p = &Person{Name: "Peter", Age: 22}
fmt.Println(p.Name) // Output: "Peter"
// Go automatically dereferences 'p' to allow
// access to the 'Name' field
Los slices y los mapas ya son punteros
Los slices y los mapas son tipos especiales porque ya tienen punteros en su implementación.
Esto significa que, la mayoría de las veces, no necesitamos crear punteros para estos tipos para compartir la dirección de memoria de sus valores.
Imagina que tenemos una función que incrementa el valor de una clave en un mapa:
func incrementPeterAge(m map[string]int) {
m["Peter"] += 1
}
Si creamos un mapa y llamamos a esta función, los cambios que la función hizo en el mapa persisten después de que la función termina.
Este es un comportamiento similar al que obtenemos si usáramos un puntero, pero fíjate en que en este ejemplo no estamos usando ninguna referencia/desreferencia ni nada de la sintaxis de punteros:
ages := map[string]int{
"Peter": 21
}
incrementPeterAge(ages)
fmt.Println(ages)
// Output: map[Peter:22]
// The changes the function 'incrementPeterAge' made to the map are visible after the function ends!
Lo mismo se aplica cuando cambiamos un elemento existente en un slice.
Sin embargo, las acciones que devuelven un nuevo slice como append son un caso especial y puede que no modifiquen el slice fuera de la función.
Esto se debe a la forma en que los slices funcionan internamente, pero no cubriremos esto en detalle en este ejercicio, ya que es un tema más avanzado.
Si tienes mucha curiosidad, puedes leer más sobre esto en Go Blog: Mechanics of 'append'
Ejercicio de aprendizaje
