¿Cómo funcionan los punteros en Go?

Question

Accepted Answer

Un **puntero** mantiene la **dirección de memoria** de un valor en lugar del valor en sí. Go tiene punteros (como C) pero los mantiene simples y seguros — sin aritmética de punteros, y el recolector de basura maneja la memoria. Se utilizan para compartir y modificar datos de manera eficiente.

## Los dos operadores: & y *

```go
x := 42
p := &x          // & = "address of" → p is a *int (pointer to x)
fmt.Println(p)   // 0xc0000... (the address)
fmt.Println(*p)  // 42 — * = "dereference" (get the value at the address)

*p = 100         // change the value THROUGH the pointer
fmt.Println(x)   // 100 — x was modified via p
```

`&` toma la dirección de una variable; `*` (en un puntero) accede o establece el valor al que señala.

## Por qué los punteros importan: modificación a través de funciones

```go
// ❌ value parameter — the function gets a COPY; changes don't affect the caller
func incrementValue(n int) { n++ }       // caller's variable unchanged

// ✅ pointer parameter — the function can modify the caller's variable
func incrementPointer(n *int) { *n++ }

x := 5
incrementValue(x)     // x still 5
incrementPointer(&x)  // x is now 6
```

Como Go pasa argumentos **por valor** (copias), una función solo puede modificar los datos del llamador si recibe un **puntero** a ellos. Esta es la razón principal para usar punteros.

## Punteros con structs (muy común)

```go
type Counter struct { count int }

// pointer receiver → method can modify the struct
func (c *Counter) Increment() { c.count++ }

c := &Counter{}      // a pointer to a Counter
c.Increment()        // modifies it (Go auto-dereferences: (*c).count++)
```

Los receptores de punteros son la forma en que los métodos mudan su struct, y pasar punteros de struct evita copiar structs grandes.

## El puntero nil y el valor cero

```go
var p *int           // zero value of a pointer is nil
fmt.Println(p)       // <nil>
*p = 5               // 💥 PANIC: nil pointer dereference (no value to point to)
if p != nil { *p = 5 }   // guard against nil
```

Desreferenciar un puntero `nil` causa pánico — un error de tiempo de ejecución común que se debe proteger.

## Lo que los punteros de Go NO tienen (seguridad)

```text
✗ NO pointer arithmetic (can't do p++ to move through memory like C)
✗ NO manual free — garbage collector reclaims memory
→ Pointers are about sharing/modifying data, not low-level memory hacking
```

## Por qué es importante

Los punteros son esenciales en Go para dos propósitos principales: **modificar** los datos del llamador (ya que Go pasa por valor, solo un puntero permite que una función cambie el original) y **eficiencia** (pasar un puntero evita copiar structs grandes).

Son fundamentales para métodos con receptores de puntero (la forma estándar de mutar structs) y aparecen en todo Go idiomático.

Comprender `&`/`*`, semántica de valor frente a puntero, el pánico de puntero nil, y que los punteros de Go sean deliberadamente *seguros* (sin aritmética, administrados por GC) — enfocados en compartir/mutación en lugar de manipulación de memoria estilo C — es conocimiento fundamental para escribir Go correcto y eficiente y un punto frecuente de confusión para principiantes y en entrevistas.