Enteros en

Acerca de Enteros

Un entero es un número que no tiene parte fraccionaria ni decimal. En la máquina se representa como un patrón de bits binarios.

Los enteros pueden tener signo o no. Tener signo significa reservar uno de los bits del número para indicar si ese número es negativo o no.

Todos los enteros tienen un ancho de bits, que es simplemente la cantidad de bits que componen el número. Esto afecta el valor máximo que puede representar ese tipo de entero.

Por ejemplo, uno de los tipos de entero más comunes es u8: un entero sin signo de 8 bits. Puede que reconozcas este tipo como un solo byte. Tiene un valor mínimo de 0 y un valor máximo de 255.

Rust tiene 12 tipos primitivos de enteros, clasificados por ancho de bits y presencia de signo:

El ancho de bits de un entero siempre se indica con el número que sigue a la u o la i. usize e isize son especiales: tienen el mismo ancho que un puntero en la máquina de destino. Esto significa que en una arquitectura de 64 bits, usize e isize tienen 64 bits de ancho, pero en una arquitectura de 32 bits, tienen 32 bits de ancho.

¿Cuál deberías usar?

En general, si solo necesitas representar algún número, usa un i32: 32 bits tiene un rango lo suficientemente amplio como para que sea relativamente poco probable que se desborde, y los números con signo tienen menos sorpresas que los números sin signo. i32 es equivalente a un long en C, o a un int en Java. Si usas un literal numérico y no anotas el tipo explícitamente, se usará i32 por defecto.

Si trabajas con datos binarios, lo más fácil es trabajar con bytes: &[u8] o Vec<u8>.

Rust usa usize para el tamaño y la indexación de las colecciones. Esto se debe a que, en teoría, una computadora solo puede direccionar usize::MAX bytes de memoria, así que no son posibles colecciones en memoria más grandes. Por lo tanto, usize puede ser útil si trabajas mucho con colecciones.

Si tus datos no caben en un entero de 32 bits, considera ampliar a un entero de 64 o 128 bits. Si tus datos no caben en un entero de 128 bits, entonces puedes usar un tipo de entero grande, como el que ofrece num-bigint.

Los enteros de 16 bits no son muy comunes, pero pueden ser útiles cuando apuntas a ciertos microcontroladores.

Si sabes que no hay casos negativos válidos para tu aplicación, es mejor usar un entero sin signo en lugar de un entero con signo. Contar es un buen ejemplo de esto.

Conversión entre enteros

Rust no tiene conversiones numéricas implícitas. Si necesitas convertir entre tipos de enteros, hay dos estrategias básicas: la palabra clave as, y los traits From y TryFrom.

Usar la palabra clave as es simple: expr as Type. Sin embargo, hay una serie de advertencias y sutilezas que debes tener en cuenta al usar conversiones con as.

La conversión basada en traits es un poco más complicada, pero más segura: los traits de conversión solo se implementan donde son seguros. Por ejemplo, i32 implementa From<u8>, From<u16>, From<i8> y From<i16>: cualquier valor representable por cualquiera de estos tipos está garantizado como representable en un i32. Se puede usar como i32::from(expr), o expr.into(), donde expr se resuelve a uno de esos tipos. i32 también implementa TryFrom<u32>, TryFrom<u64>, TryFrom<u128>, TryFrom<usize>, TryFrom<i64>, TryFrom<i128> y TryFrom<isize>. Estas conversiones explícitamente tendrán éxito o se desbordarán, dependiendo del valor. Para usarlas, necesitarás importar los traits std::convert::TryFrom o std::convert::TryInto según corresponda, y luego usar i32::try_from(expr) o expr.try_into(), donde expr se resuelve a un tipo adecuado.

En general, se prefiere usar la conversión basada en traits en lugar de la conversión con as, sobre todo cuando se convierte de un tipo más ancho a uno más angosto. La conversión basada en traits es un poco más costosa que la conversión con as, de forma insignificante: usar as por razones de rendimiento no vale la pena, salvo en un bucle extremadamente crítico.