Un puntero en Go es una variable que almacena la dirección de memoria de otro valor, permitiendo el acceso indirecto y la mutación de datos a través de los operadores de dirección (&) y desreferencia (*). A diferencia de C, Go no permite la aritmética de punteros de forma nativa en su modo seguro, lo que elimina una categoría entera de errores de memoria mientras mantiene el control sobre la disposición de los datos.
La existencia de punteros en Go permite optimizar el rendimiento al evitar la copia de estructuras de datos voluminosas durante las llamadas a funciones. En lugar de duplicar el valor en el stack, el programa pasa una dirección de memoria, permitiendo que múltiples partes del sistema operen sobre la misma instancia subyacente. Esto resuelve la dicotomía entre la seguridad de los lenguajes gestionados y la eficiencia del acceso directo a memoria de los lenguajes de sistemas.
Mecánica de direccionamiento y semántica de asignación
El operador de dirección & genera un puntero hacia su operando. Si una variable es de tipo T, la expresión &variable genera un valor de tipo *T. Por el contrario, el operador de desreferencia * se aplica sobre una variable de tipo puntero para acceder al valor almacenado en la dirección apuntada. En términos de assignability, un puntero solo puede asignarse a otro del mismo tipo base, garantizando la seguridad de tipos en tiempo de compilación.
Go es estrictamente un lenguaje de “paso por valor”. Cuando se pasa un puntero a una función, Go crea una copia de la dirección de memoria (el valor del puntero), no del dato al que apunta. Esto significa que si se modifica el puntero mismo dentro de la función (apuntándolo a otra dirección), el cambio no se refleja en el llamador; sin embargo, si se desreferencia el puntero para modificar el valor subyacente, el cambio será persistente.
package main
import "fmt"
type Config struct {
Active bool
}
func main() {
val := 42
ptr := &val // Obtener dirección de memoria
fmt.Printf("Tipo de ptr: %T\n", ptr) // → *int
fmt.Printf("Valor de val: %v\n", *ptr) // Desreferencia → 42
cfg := Config{Active: false}
// Paso por valor (copia de la estructura)
updateValue(cfg)
fmt.Println("Paso por valor:", cfg.Active) // → false
// Paso por dirección (copia del puntero)
updateReference(&cfg)
fmt.Println("Paso por referencia:", cfg.Active) // → true
}
func updateValue(c Config) {
c.Active = true // Modifica una copia local en el stack
}
func updateReference(c *Config) {
c.Active = true // Desreferencia implícita y mutación del original
}
El comportamiento más destacable en el código anterior es la desreferencia implícita en selectores. En Go, no es necesario escribir (*c).Active para acceder a un campo de una estructura a través de un puntero; el compilador resuelve automáticamente la dirección si el tipo base es un puntero a una estructura.
Escape Analysis y el ciclo de vida en el Heap
Un aspecto no evidente del compilador de Go es el escape analysis. A diferencia de C, donde devolver un puntero a una variable local de una función resulta en un comportamiento indefinido (puntero colgante), el compilador de Go detecta si una variable “escapa” al ámbito de la función.
Promoción al Heap por retorno de dirección
Si el compilador determina que una variable local sigue siendo referenciada después de que la función retorne, mueve dicha variable del stack al heap automáticamente. Esto garantiza que el puntero devuelto siempre apunte a una dirección de memoria válida. Este mecanismo permite una flexibilidad sintáctica superior, pero el desarrollador debe ser consciente de que el uso excesivo de punteros que escapan puede incrementar la presión sobre el Garbage Collector (GC), afectando la latencia del sistema bajo cargas de trabajo intensas.
- Módulo: Léxico y Sintaxis Fundamental
- Artículo número: #9