Un puntero en Go es un tipo de dato que almacena la dirección de memoria de un valor de otro tipo, permitiendo la manipulación indirecta de los datos y la gestión eficiente de la memoria sin recurrir a la duplicación de estructuras masivas en el stack.
Go utiliza este mecanismo para ofrecer un control preciso sobre la mutabilidad y la localidad de los datos, resolviendo el compromiso entre rendimiento y seguridad que otros lenguajes gestionan mediante referencias opacas. A diferencia de lenguajes de bajo nivel como C, Go prohíbe la aritmética de punteros por defecto, lo que garantiza la integridad de la memoria y facilita las tareas de rastreo del Garbage Collector (GC), evitando errores comunes como el acceso a segmentos de memoria fuera de los límites permitidos.
La declaración de un puntero se realiza anteponiendo un asterisco al tipo base (*T), mientras que el operador de dirección (&) se utiliza para obtener la dirección de memoria de una variable existente. El valor inicial de un puntero no inicializado es siempre nil, lo que indica la ausencia de una dirección válida. Para la reserva de memoria, Go proporciona la función predefinida new(T). Esta función asigna un bloque de memoria puesto a cero para un valor de tipo T, devolviendo un puntero de tipo *T. Es una herramienta fundamental cuando se requiere inicializar punteros antes de asignarles valores específicos, asegurando que la estructura apunte a un espacio de memoria válido y tipado.
En el contexto de los structs, Go implementa una optimización sintáctica crucial conocida como indirección automática o “azúcar sintáctico”. En lenguajes más rígidos, acceder a un campo de un struct a través de un puntero requeriría desreferenciarlo explícitamente usando la sintaxis (*p).Campo. Go simplifica este proceso permitiendo el uso directo del operador de punto (p.Campo). El compilador detecta si la variable es un puntero y realiza la desreferenciación de forma transparente, mejorando drásticamente la ergonomía del código sin sacrificar la precisión del sistema de tipos.
package main
import "fmt"
type Datos struct {
ID int
Valor float64
}
func main() {
// Uso de new(T) para alocar memoria puesta a cero
p1 := new(Datos) // p1 es de tipo *Datos
// Sintaxis azucarada p.Field en lugar de (*p).Field
p1.ID = 101 // Equivalente a (*p1).ID = 101
p1.Valor = 45.5 // Acceso directo a través del puntero
// Declaración y obtención de dirección con &
numero := 42
ptrNumero := &numero // ptrNumero es de tipo *int
// Desreferenciación explícita para tipos básicos
fmt.Printf("Valor original: %d\n", *ptrNumero) // → 42
*ptrNumero = 100 // Modificación indirecta
fmt.Printf("Número modificado: %d\n", numero) // → 100
// El zero value de un puntero es nil
var ptrNil *int
fmt.Printf("Puntero sin inicializar: %v\n", ptrNil) // → <nil>
}
La desreferenciación automática es un mecanismo de conveniencia que solo aplica a la selección de campos y llamadas a métodos; para tipos básicos como int o string, la desreferenciación mediante * sigue siendo estrictamente necesaria para acceder o modificar el valor subyacente.
Indirección automática y el riesgo de Nil Pointer Dereference
Un comportamiento crítico del compilador de Go es que la resolución de la sintaxis p.Campo no incluye una comprobación de seguridad contra valores nulos en tiempo de ejecución. Si bien el programador escribe un código más limpio, el mecanismo interno sigue realizando una desreferenciación que fallará catastróficamente si el puntero es nil.
Un edge case real ocurre al trabajar con métodos que tienen receptores de puntero. Go permite llamar a un método sobre un puntero nil sin que la llamada en sí falle, siempre y cuando el método no intente acceder a un campo del struct dentro de su lógica. Sin embargo, en el momento en que se intenta acceder a un campo mediante p.Campo dentro de ese método, el runtime disparará un panic: runtime error: invalid memory address or nil pointer dereference. Esta distinción es fundamental: el azúcar sintáctico facilita la escritura, pero no exime al desarrollador de validar la integridad del puntero en puntos donde la nulidad sea una posibilidad lógica.
- Módulo: Sistema de Tipos
- Artículo número: #28