Los tipos numéricos de tamaño fijo en Go son tipos de datos cuya representación en memoria, precisión y rango de valores están estrictamente definidos por la especificación del lenguaje, garantizando un comportamiento idéntico independientemente de la arquitectura del procesador. A diferencia de los tipos de tamaño calculado como int o uint —que pueden variar entre 32 y 64 bits según la plataforma—, estos tipos ofrecen un control granular sobre la estructura de datos y la interoperabilidad binaria.
Este diseño responde a la necesidad de predecibilidad en el desarrollo de sistemas. En lenguajes donde los tipos numéricos son ambiguos, la migración de código entre arquitecturas puede introducir errores de desbordamiento o cambios en el consumo de memoria. Go elimina esta incertidumbre obligando al desarrollador a declarar explícitamente el ancho del tipo cuando la precisión es crítica, fomentando un uso eficiente de la memoria en sistemas de alta concurrencia o en la definición de protocolos de red.
La jerarquía de enteros se divide en dos categorías: con signo (int8, int16, int32, int64) y sin signo (uint8, uint16, uint32, uint64). Los tipos con signo utilizan la representación de complemento a dos, lo que define su rango desde $-2^{(n-1)}$ hasta $2^{(n-1)}-1$. Los tipos sin signo aprovechan el bit de signo para extender el rango positivo hasta $2^n-1$. El compilador de Go es riguroso respecto a la compatibilidad de tipos; un int32 y un int64 se consideran tipos distintos incluso si el valor almacenado es compatible. No existe la promoción automática de tipos (type promotion), lo que exige conversiones explícitas para cualquier operación entre tipos numéricos diferentes.
Los tipos de punto flotante float32 y float64 siguen estrictamente el estándar IEEE-754. Mientras que float32 es útil para ahorrar espacio en grandes arreglos o procesamiento de gráficos, float64 es el estándar de facto para cálculos científicos debido a su mayor precisión. Por su parte, los tipos complejos (complex64 y complex128) integran dos valores de punto flotante para representar las partes real e imaginaria, simplificando la implementación de algoritmos matemáticos avanzados sin depender de librerías externas para la gestión de números complejos.
package main
import (
"fmt"
"math"
"unsafe"
)
func main() {
// Enteros de tamaño fijo
var a int8 = 127
var b int16 = 32767
// El compilador prohíbe: c := a + b (mismatch)
c := int16(a) + b // Conversión explícita requerida
fmt.Printf("Tipo: %T, Tamaño: %d bytes, Valor: %d\n", c, unsafe.Sizeof(c), c)
// Output: Tipo: int16, Tamaño: 2 bytes, Valor: 32894
// Tipos sin signo (uint)
var d uint64 = math.MaxUint64
fmt.Printf("uint64 max: %d\n", d)
// Punto flotante y precisión
var f32 float32 = math.Pi
var f64 float64 = math.Pi
fmt.Printf("f32: %.10f, f64: %.10f\n", f32, f64)
// f32: 3.1415927410, f64: 3.1415926536
// Números complejos
// complex128 utiliza dos float64 (16 bytes)
z := complex(5, 10) // 5 + 10i
fmt.Printf("Complex: %v, Real: %v, Imag: %v\n", z, real(z), imag(z))
// Complex: (5+10i), Real: 5, Imag: 10
}
La restricción más contraintuitiva para desarrolladores que provienen de C++ o Java es la ausencia total de coerción implícita, incluso cuando se operan constantes sin tipo con variables de tamaño fijo. Si bien una constante numérica puede adaptarse al tipo de la variable que la recibe, una vez que el valor está “tipado” en una variable, la rigidez del sistema de tipos de Go impide cualquier mezcla operativa sin intervención manual.
Aritmética Modular y el Comportamiento del Desbordamiento en Runtime
Un aspecto crítico en el comportamiento interno de Go es cómo gestiona el desbordamiento (overflow). En operaciones con enteros de tamaño fijo, Go no genera un panic ni interrumpe la ejecución cuando un cálculo excede el rango máximo del tipo. En su lugar, el lenguaje implementa aritmética modular (wraparound). Por ejemplo, si se incrementa un uint8 con valor 255, el resultado será 0.
Este comportamiento es determinista y eficiente a nivel de CPU, pero puede introducir errores lógicos silenciosos. Un edge case común ocurre al restar valores de tipos uint; si el resultado debería ser negativo, la variable “dará la vuelta” hacia el valor máximo del tipo, generando un número positivo extremadamente grande. El desarrollador debe implementar validaciones de rango antes de la operación si el dominio del problema no tolera el comportamiento modular, ya que el compilador solo detectará desbordamientos en tiempo de compilación si estos ocurren en constantes literales.
- Módulo: Sistema de Tipos
- Artículo número: #18