Punteros y el Operador Address-of

Los punteros almacenan la dirección de un valor, permitiendo la mutación entre límites de funciones y evitando copias grandes.

Go tiene punteros pero no aritmética de punteros, manteniendo la seguridad de memoria sencilla.

Resumen

&x toma la dirección de x; *p desreferencia el puntero p.

Los argumentos de función se pasan por valor; comparte mutaciones pasando punteros.

Los receptores de métodos pueden ser valores o punteros; los receptores de puntero son necesarios cuando los métodos modifican el estado.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

package main
 
import "fmt"
 
func increment(n *int) {
    *n++ // Desreferencia el puntero y lo incrementa
}
 
func main() {
    count := 10
    increment(&count) // Pasa la dirección de count
    fmt.Println(count) // Imprime 11
}

Cuándo usar esto:

• Modificar el estado del llamador desde una función.
• Evitar copiar estructuras grandes en rutas críticas (perfila primero).
• Representar campos opcionales o anulables con *T.
• Implementar métodos que modifican los campos del receptor.

Ejemplo Funcional

package main
 
import "fmt"
 
// Config es una estructura de ejemplo.
type Config struct {
    Host string
    Port int
}
 
// SetPort es un método con un receptor de puntero que modifica la estructura.
func (c *Config) SetPort(p int) {
    c.Port = p // Modifica el campo Port de la estructura original
}
 
// clone copia una estructura Config por valor.
func clone(cfg Config) Config {
    return cfg // La estructura se copia por valor
}
 
func main() {
    cfg := Config{Host: "localhost", Port: 8080}
    cfg.SetPort(9090) // Llama al método receptor de puntero, cfg.Port ahora es 9090
 
    copy := clone(cfg) // Crea una copia de cfg
    copy.Port = 1      // Modifica la copia; cfg.Port permanece sin cambios
    fmt.Println(cfg.Port, copy.Port) // Imprime 9090 1
 
    var p *int // Declara un puntero a int, inicialmente nil
    if p != nil {
        // Este bloque no se ejecutará porque p es nil
        fmt.Println(*p) // Desreferenciar un puntero nil provocaría un pánico
    } else {
        fmt.Println("p is nil") // Imprime "p is nil"
    }
}

Lo que esto demuestra:

• El receptor de puntero SetPort muta cfg in situ.
• La asignación de estructuras copia valores: copy.Port no afecta a cfg.
• La comprobación de puntero nulo antes de la desreferencia evita pánicos.
• No se necesita & al llamar a métodos con receptor de puntero en valores direccionables.

Inmersión Profunda

Cómo Funciona

• Las variables viven en la pila o en el heap basándose en el análisis de escape, no en si tomas &.
• new(T) asigna un T inicializado a cero y devuelve *T; el código idiomático a menudo usa &T{}.
• Los punteros nil se comparan igual entre sí y con nil sin tipo en un contexto de puntero tipado.
• Las interfaces que contienen punteros nulos tipados no son iguales a una interfaz nil.

Paso por Valor vs. Puntero

Selección de Receptor

Notas de Go

// Campo opcional
type User struct {
    Name string
    Nick *string // nil significa no establecido
}
 
// No pases un puntero a una variable de bucle sin copiarlo
for i := 0; i < 3; i++ {
    n := i // Crea una copia local de i para cada iteración
    go func() { fmt.Println(&n) }() // Ahora cada goroutine imprime un valor diferente
}

Trampas

• Desreferencia de puntero nulo - *p cuando p == nil provoca un pánico. Solución: comprueba p != nil o garantiza la construcción.
• Nil tipado en interfaces - return (*T)(nil), err todavía hace que la interfaz no sea nil. Solución: devuelve una interfaz nil o un tipo de valor concreto.
• Puntero a cabecera de mapa/slice - Raramente necesario; los slices/mapas ya mutan a través de una cabecera compartida. Solución: pasa el slice/mapa directamente.
• Tomar la dirección de la variable de rango - Las variables de bucle anteriores a la v1.22 reutilizaban una dirección. Solución: copia item := item dentro del bucle.
• Uso excesivo de punteros - Las estructuras pequeñas cuestan menos de copiar que la indirección y la presión del GC. Solución: pasa por valor hasta que el perfilado diga lo contrario.
• Mutación a través de puntero a datos constantes - No se puede apuntar a constantes sin tipo; se debe apuntar a variables.

Alternativas

Preguntas Frecuentes

Relacionado

• Estructuras, Incrustación y Promoción de Campos - Receptores de puntero en tipos compuestos
• Valores Cero e Inicialización - Punteros nulos y new
• Variables, Constantes y Ámbito - Dirección de variables de bucle
• Arrays, Slices y Maps de un Vistazo - Cuándo los punteros aportan poco valor para slices

Enlaces Externos Relacionados

• A Tour of Go - Introducción interactiva oficial a Go.
• Effective Go - Guía oficial para escribir Go claro e idiomático.
• Go by Example - Ejemplos de código prácticos anotados.
• Learning Go (2nd Edition) - Jon Bodner.
• Get Programming with Go (Manning) - Nathan Youngman & Roger Peppé.

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado de GC Green Tea, go fix modernizers - verifica el parche en la compilación), chi (última versión - verifica en la compilación), gin (última versión - verifica en la compilación), echo (última versión - verifica en la compilación), google.golang.org/grpc (última versión - verifica en la compilación), sigs.k8s.io/controller-runtime (última versión - verifica en la compilación), kubebuilder (última versión - verifica en la compilación), tinygo (última versión - verifica los objetivos de la placa en la compilación), wazero (última versión - verifica en la compilación) y golangci-lint (última versión - verifica el conjunto de linters en la compilación).