Punteros en Golang: & y *, new, nil y cuándo usarlos

& y *

Un puntero contiene la dirección de memoria de un valor. &x te da un puntero a x. *p sigue el puntero hasta el valor.

package main

import "fmt"

func main() {
	x := 10
	p := &x // p has type *int

	fmt.Println(*p) // read through the pointer: 10
	*p = 20         // write through the pointer
	fmt.Println(x)  // x changed: 20

	fmt.Printf("%T\n", p)
	fmt.Println(p != nil)
}

El asterisco tiene dos papeles. En un tipo (*int) significa "puntero a int". En una expresión (*p) significa "el valor al que apunta p". Imprimir p directamente muestra una dirección como 0xc000012345, que cambia entre ejecuciones.

Por qué existen los punteros: compartir en lugar de copiar

Go lo pasa todo por valor. Una función recibe una copia de cada argumento, así que no puede cambiar la variable de quien la llama. Pasar un puntero copia la dirección, y los dos lados llegan al mismo valor.

package main

import "fmt"

func doubleCopy(n int) {
	n *= 2
}

func doublePtr(n *int) {
	*n *= 2
}

func main() {
	v := 21
	doubleCopy(v)
	fmt.Println(v) // 21

	doublePtr(&v)
	fmt.Println(v) // 42
}

Go no tiene referencias en el sentido de C++. "Paso por referencia" en Go significa pasar un puntero por valor.

Punteros a structs

Los punteros a structs son los más comunes en el código Go. El acceso a campos desreferencia automáticamente: p.Name significa (*p).Name.

package main

import "fmt"

type Account struct {
	Owner   string
	Balance int
}

func (a *Account) Deposit(n int) {
	a.Balance += n // no explicit * needed
}

func main() {
	acc := &Account{Owner: "Ana"} // pointer to a new struct
	acc.Deposit(100)
	acc.Balance -= 30
	fmt.Println(acc.Owner, acc.Balance)

	same := acc
	same.Balance = 0
	fmt.Println(acc.Balance) // 0: both variables point at one Account
}

Los métodos siguen la misma lógica: un receptor puntero permite al método cambiar el struct. La página de métodos explica la elección entre receptor por valor y por puntero.

new

new(T) reserva un T a cero y devuelve su dirección. Es lo mismo que declarar una variable y tomar su dirección.

p := new(int) // *int pointing at 0
var x int
q := &x           // same thing, two lines
a := new(Account) // same as &Account{}

En la práctica, &T{...} es más común para los structs porque permite asignar campos en la misma expresión. new viene bien para punteros a tipos básicos. No lo confundas con make, que construye slices, maps y channels y los devuelve listos para usar, no como punteros.

Devolver un puntero a una variable local es seguro

En C, devolver la dirección de una variable local es un bug. En Go es código normal.

package main

import "fmt"

type Config struct {
	Port int
	Mode string
}

func defaultConfig() *Config {
	c := Config{Port: 8080, Mode: "dev"}
	return &c // c outlives the call, so it lives on the heap
}

func main() {
	cfg := defaultConfig()
	cfg.Mode = "prod"
	fmt.Printf("%+v\n", *cfg)
}

El análisis de escape del compilador decide si un valor vive en la pila o en el heap. Tú nunca lo eliges, y nunca liberas memoria: el recolector de basura la recupera cuando nada apunta a ella. go build -gcflags=-m imprime esas decisiones si tienes curiosidad.

Punteros nil

El valor cero de cualquier tipo puntero es nil. Desreferenciar nil provoca un panic.

package main

import "fmt"

type Node struct {
	Val  int
	Next *Node
}

func main() {
	defer func() {
		fmt.Println("recovered:", recover())
	}()

	list := &Node{Val: 1, Next: &Node{Val: 2}}
	for n := list; n != nil; n = n.Next {
		fmt.Println(n.Val)
	}

	var missing *Node
	fmt.Println(missing == nil)
	fmt.Println(missing.Val) // panics
}

Salida:

1
2
true
recovered: runtime error: invalid memory address or nil pointer dereference

Sin el recover, el programa caería con ese mensaje y una traza de la pila que empieza con panic: runtime error: invalid memory address or nil pointer dereference y [signal SIGSEGV: segmentation violation ...]. Los orígenes habituales:

• una variable puntero o un campo de struct que nunca se asignó
• m[key] sobre un map[string]*T con una clave que no existe, que devuelve nil
• ignorar un error: f, _ := os.Open(path) deja f a nil si falla
• un método con receptor puntero llamado sobre un puntero nil, que luego lee un campo

Llamar a un método sobre un puntero nil es legal en sí. El panic ocurre solo cuando el método toca los campos del receptor.

Cuándo usar un puntero

Usa un puntero cuando:

• una función o un método tiene que cambiar el valor de quien llama
• el valor es un struct grande y se pasa de un lado a otro a menudo
• el tipo no debe copiarse (contiene un sync.Mutex, o representa un recurso único como una conexión)
• necesitas expresar "sin valor" con nil, por ejemplo un campo opcional en un struct JSON (*int distingue "ausente" de 0)

No uses un puntero cuando:

• el valor es pequeño y de solo lectura (time.Time, un Point)
• el tipo ya se comporta como una referencia: los slices, maps, channels, funciones e interfaces rara vez necesitan un * delante. Un *[]int o un *map[string]int es casi siempre un error

Los punteros no son automáticamente más rápidos. Copiar un struct pequeño es barato, y un puntero puede forzar una reserva en el heap y añadir trabajo al recolector de basura.

Punteros y variables de bucle

Tomar la dirección de una variable de bucle es seguro desde Go 1.22, porque cada iteración tiene su propia variable:

package main

import "fmt"

func main() {
	var ptrs []*int
	for i := range 3 {
		ptrs = append(ptrs, &i)
	}
	for _, p := range ptrs {
		fmt.Print(*p, " ")
	}
	fmt.Println()
}

Esto imprime 0 1 2. Antes de Go 1.22 (que también introdujo range 3), el mismo bucle escrito como for i := 0; i < 3; i++ imprimía 3 3 3, porque los tres punteros compartían una sola variable. Ten en cuenta que &v en for _, v := range items apunta a una copia del elemento, no al elemento del slice. Para obtener un puntero al propio elemento, usa &items[i].

Errores comunes

• Desreferenciar sin comprobar. Comprueba if p == nil donde nil sea posible.
• Puntero a un valor de range. &v apunta a una copia; usa &s[i].
• Punteros a slices y maps. Rara vez hacen falta. Devuelve el slice nuevo.
• Guardar &s[i] a través de un append. Si append reserva un array nuevo, el puntero sigue apuntando al array antiguo y las escrituras posteriores no se ven en ningún sitio.