Enteros

Enteros

Move admite seis tipos de enteros sin signo: u8, u16, u32, u64, u128y u256. Los valores de estos tipos oscilan entre 0 y un máximo que depende del tamaño del tipo.

Tipo	Rango de valores
Entero de 8 bits sin signo,u8	0 a 28 - 1
Entero de 16 bits sin signo,u16	0 a 216 - 1
Entero de 32 bits sin signo,u32	0 a 232 - 1
Entero de 64 bits sin signo,u64	0 a 264 - 1
Entero de 128 bits sin signo,u128	0 a 2128 - 1
Entero de 256 bits sin signo,u256	0 a 2256 - 1

Literales

Los valores literales para estos tipos se especifican como una secuencia de dígitos (por ejemplo, 112) o como literales hexadecimales, por ejemplo, 0xFF. Opcionalmente, el tipo de literal se puede agregar como un sufijo, por ejemplo, 112u8. Si no se especifica el tipo, el compilador intentará inferir el tipo a partir del contexto donde se utiliza el literal. Si no se puede inferir el tipo, se supone que es u64. Los literales numéricos se pueden separar mediante guiones bajos para agruparlos y facilitar su lectura. (p. ej. 1_234_5678, 1_000u128, 0xAB_CD_12_35). Si un literal es demasiado grande para su rango de tamaño especificado (o inferido), se informa un error.

Ejemplos

Copiar

// literals with explicit annotations;
let explicit_u8 = 1u8;
let explicit_u16 = 1u16;
let explicit_u32 = 1u32;
let explicit_u64 = 2u64;
let explicit_u128 = 3u128;
let explicit_u256 = 1u256;
let explicit_u64_underscored = 154_322_973u64;

// literals with simple inference
let simple_u8: u8 = 1;
let simple_u16: u16 = 1;
let simple_u32: u32 = 1;
let simple_u64: u64 = 2;
let simple_u128: u128 = 3;
let simple_u256: u256 = 1;

// literals with more complex inference
let complex_u8 = 1; // inferred: u8
// right hand argument to shift must be u8
let _unused = 10 << complex_u8;

let x: u8 = 38;
let complex_u8 = 2; // inferred: u8
// arguments to `+` must have the same type
let _unused = x + complex_u8;

let complex_u128 = 133_876; // inferred: u128
// inferred from function argument type
function_that_takes_u128(complex_u128);

// literals can be written in hex
let hex_u8: u8 = 0x1;
let hex_u16: u16 = 0x1BAE;
let hex_u32: u32 = 0xDEAD80;
let hex_u64: u64 = 0xCAFE;
let hex_u128: u128 = 0xDEADBEEF;
let hex_u256: u256 = 0x1123_456A_BCDE_F;

Operaciones

Aritmética

Cada uno de estos tipos admite el mismo conjunto de operaciones aritméticas comprobadas. Para todas estas operaciones, ambos argumentos (los operandos del lado izquierdo y derecho) deben ser del mismo tipo. Si necesita operar sobre valores de diferentes tipos, primero deberá realizar una conversión . De manera similar, si espera que el resultado de la operación sea demasiado grande para el tipo de entero, realice una conversión a un tamaño mayor antes de realizar la operación. Todas las operaciones aritméticas se abortan en lugar de comportarse de una manera que los enteros matemáticos no lo harían (por ejemplo, desbordamiento). , subdesbordamiento, división por cero).

Sintaxis	Operación	Aborta si
+	suma	El resultado es demasiado grande para el tipo de número entero
-	sustracción	El resultado es menor que cero.
*	multiplicación	El resultado es demasiado grande para el tipo de número entero
%	división modular	el divisor es0
/	división truncada	el divisor es0

Bit a bit

Los tipos de números enteros admiten las siguientes operaciones bit a bit que tratan cada número como una serie de bits individuales, ya sea 0 o 1, en lugar de valores numéricos enteros. Las operaciones bit a bit no se cancelan.

Sintaxis	Operación	Descripción
&	bit a bit y	Realiza un booleano y para cada bit por pares.
|	bit a bit o	Realiza un booleano o para cada bit por pares.
^	xor bit a bit	Realiza una exclusiva booleana o para cada bit por pares

Cambios de bits

De manera similar a las operaciones bit a bit, cada tipo de entero admite cambios de bits. Pero a diferencia de otras operaciones, el operando del lado derecho (el número de bits a desplazar) siempre debe ser a u8y no necesita coincidir con el operando del lado izquierdo (el número que está desplazando). Los desplazamientos de bits pueden abortar si el número de bits a desplazar es mayor o igual a , 8, 16, 32, 64o 128para 256, u8, u16, u32y u64respectivamente .u128u256

Sintaxis	Operación	Aborta si
<<	desplazamiento a la izquierda	El número de bits a desplazar es mayor que el tamaño del tipo de número entero
>>	cambio a la derecha	El número de bits a desplazar es mayor que el tamaño del tipo de número entero

Comparaciones

Los tipos de números enteros son los únicos tipos en Move que pueden usar operadores de comparación. Ambos argumentos deben ser del mismo tipo. Si necesita comparar números enteros de diferentes tipos, primero deberá convertir uno de ellos. Las operaciones de comparación no se cancelan.

Sintaxis	Operación
<	menos que
>	mas grande que
<=	Menos que o igual a
>=	Mayor qué o igual a

Igualdad

Como todos los tipos dropen Move, todos los tipos de números enteros admiten las operaciones "igual" y "no igual". Ambos argumentos deben ser del mismo tipo. Si necesita comparar números enteros de diferentes tipos, primero deberá convertir uno de ellos. Las operaciones de igualdad no se cancelan.

Sintaxis	Operación
==	igual
!=	no es igual

Para más detalles ver el apartado de igualdad

Fundición

Los tipos enteros de un tamaño se pueden convertir en tipos enteros de otro tamaño. Los números enteros son los únicos tipos en Move que admiten la conversión. Las conversiones no se truncan. La conversión se cancelará si el resultado es demasiado grande para el tipo especificado

Sintaxis	Operación	Aborta si
(e as T)	Convertir una expresión entera een un tipo enteroT	ees demasiado grande para representarlo comoT

Aquí, el tipo de edebe ser 8, 16, 32, 64o y debe ser , , , , oe . 128Por ejemplo:256Tu8u16u32u64u128u256

• (x as u8)

• (y as u16)

• (873u16 as u32)

• (2u8 as u64)

• (1 + 3 as u128)

• (4/2 + 12345 as u256)

Propiedad

Al igual que con los otros valores escalares integrados en el lenguaje, los valores enteros se pueden copiar implícitamente, lo que significa que se pueden copiar sin una instrucción explícita como copy.