El paquete unsafe no es parte de la biblioteca estándar en el sentido tradicional, sino que es un conjunto de primitivas que el compilador permite usar para saltarse el sistema de tipos de Go. Básicamente, te permite tratar cualquier dirección de memoria como cualquier otro tipo de dato. En Go, la seguridad de tipos es la garantía de que no accederás a memoria que no te pertenece o que interpretarás bytes de forma incorrecta. unsafe rompe esa garantía.
Para entenderlo, piensa en la memoria de tu máquina. El sistema operativo solo ve una secuencia gigante de bytes. El sistema de tipos de Go es una capa de abstracción que le dice al compilador: “estos 4 bytes son un int32 y este *User apunta a una estructura”. unsafe.Pointer es el tipo que le dice al compilador: “olvida lo que sabes; esto es solo una dirección de memoria bruta”.
Esto es necesario porque, aunque Go es altamente eficiente, tiene costos de abstracción. Si estás construyendo un motor de bases de datos, un driver de red de ultra-baja latencia o una librería de serialización que debe procesar gigabytes de datos por segundo, no puedes permitirte el lujo de copiar buffers de []byte a structs usando encoding/binary o reflexión. En esos casos, el casting de memoria directo (zero-copy) es la única vía para alcanzar el rendimiento del hardware.
Sin embargo, este poder conlleva un contrato peligroso: la responsabilidad de la integridad de la memoria pasa de ser del compilador a ser exclusivamente tuya. Si usas unsafe incorrectamente, no obtendrás un error de compilación, sino una corrupción de memoria silenciosa o un segmentation fault que será un infierno de depurar.
package main
import (
"fmt"
"unsafe"
)
// Packet representa un encabezado de un protocolo de red binario.
// El layout en memoria es crítico aquí.
type Packet struct {
ID uint32 // 4 bytes
Version uint16 // 2 bytes
Flags uint8 // 1 byte
// Nota: El compilador podría añadir padding aquí para alinear la estructura.
}
func main() {
// Simulamos un buffer de red recibido por un socket.
// El layout es: ID (4 bytes), Version (2 bytes), Flags (1 byte), + 1 byte de padding.
rawData := []byte{0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0xFF, 0x00}
// 1. Casting de []byte a *Packet (Zero-copy)
// Obtenemos el puntero al primer elemento del slice.
packetPtr := (*Packet)(unsafe.Pointer(&rawData[0]))
fmt.Printf("ID: %d, Version: %d, Flags: %d\n",
packetPtr.ID, packetPtr.Version, packetPtr.Flags)
// 2. Inspección de metadatos de memoria
fmt.Printf("Tamaño de Packet: %d bytes\n", unsafe.Sizeof(Packet{}))
fmt.Printf("Alineación de Packet: %d bytes\n", unsafe.Alignof(Packet{}))
fmt.Printf("Offset de Flags: %d bytes\n", unsafe.Offsetof(packetPtr.Flags))
// 3. Aritmética de punteros manual para acceder a un campo específico
// Queremos saltar exactamente al campo 'Flags' sin usar el struct.
// Primero convertimos a uintptr para poder sumar bytes.
baseAddr := uintptr(unsafe.Pointer(packetPtr))
flagsOffset := unsafe.Offsetof(packetPtr.Flags)
flagsAddr := unsafe.Pointer(baseAddr + flagsOffset)
// Convertimos la dirección calculada de vuelta a un puntero de tipo uint8.
flagsValue := *(*uint8)(flagsAddr)
fmt.Printf("Valor de Flags vía aritmética: %d\n", flagsValue)
}
En el ejemplo anterior, hemos realizado un “cast” de un slice de bytes directamente a una estructura Packet. La clave está en unsafe.Pointer(&rawData[0]). Al convertir la dirección del primer elemento en un unsafe.Pointer, le estamos dando permiso al compilador para interpretar esos bytes iniciales como si fueran el inicio de una estructura Packet.
Es vital entender la transición: &rawData[0] (un puntero de tipo *byte) $\rightarrow$ unsafe.Pointer (un puntero genérico que el GC entiende) $\rightarrow$ *Packet (un puntero tipado). Si intentáramos hacer uintptr(unsafe.Pointer(&rawData[0])) + offset y luego intentar convertir ese uintptr directamente a *Packet, estaríamos entrando en terreno altamente peligroso.
Fíjate en la parte de aritmética de punteros. Para movernos por la memoria, no podemos operar sobre unsafe.Pointer directamente porque Go no permite aritmética sobre punteros por razones de seguridad. El flujo correcto es: convertir a uintptr (que es simplemente un número entero lo suficientemente grande como para contener una dirección), realizar la suma del unsafe.Offsetof y, lo más importante, convertir ese resultado de nuevo a unsafe.Pointer antes de intentar desreferenciarlo.
El uso de unsafe.Offsetof es la forma correcta de navegar la estructura de forma segura, ya que tiene en cuenta el padding que el compilador inserta para cumplir con las reglas de alineación de la arquitectura (como vemos con el tamaño de Packet que probablemente sea 8 bytes aunque la suma de sus campos sea 7).
El error frecuente
El error más sutil y devastador con unsafe ocurre cuando intentas realizar aritmética de punteros y el Garbage Collector (GC) se activa en medio de la operación.
// ERROR CRÍTICO: No hagas esto ptr := unsafe.Pointer(&miStruct) addr := uintptr(ptr) + 8 // Convertimos a uintptr para sumar // --- Si el GC corre aquí, 'miStruct' podría ser movida por el runtime --- nuevoPtr := unsafe.Pointer(addr) // 'nuevoPtr' ahora apunta a basura o memoria inválida
Un uintptr es solo un número para el GC; no es un puntero. Si el recolector de basura decide mover tu objeto en memoria (lo cual puede pasar en implementaciones de Go que usen compilación compacta o durante una fase de reorganización), el valor en addr se quedará apuntando a la dirección antigua, que ya no es válida. La regla de oro es: la conversión a uintptr debe ocurrir y finalizar en la misma línea o bloque de código donde se realiza la aritmética, y debe convertirse de vuelta a unsafe.Pointer inmediatamente.
N° 179