Cómo usar la función size_of en óxido

En Rust, podemos determinar el tamaño de un tipo específico utilizando la función size_of. Esta función está en núcleo :: mem :: size_of y toma un tipo y devuelve su tamaño en bytes.

Aprendamos cómo usar la función size_of para determinar el tamaño de varios tipos en óxido.

Tamaño de óxido de tipos primitivos

Podemos determinar el tamaño de los tipos primitivos de óxido utilizando la función size_of. La sintaxis general de la función size_of es la que se muestra a continuación:

pub const fn size_of()

Como se mencionó, la función devolverá el tamaño del tipo especificado en bytes. El óxido establece que el tamaño de un tipo no es estable en compilaciones cruzadas, excepto para tipos primitivos.

Usemos el siguiente ejemplo para determinar el tamaño de un tipo booleano:

usar std :: mem;
fn main ()
println!("Tamaño de Bool: byte", mem :: size_of ::());

El programa de ejemplo importa el módulo de memoria desde la biblioteca estándar. Esto nos da acceso a la función size_of para determinar el tamaño de un bool.

Luego, llamamos a la función dentro del método println y devolvemos el tamaño de un tipo booleano.

La salida resultante es como se muestra a continuación:

$ Cargo Run
Tamaño de bool: 1 byte

Podemos hacer esto para todos los demás tipos primitivos en óxido. A continuación se proporciona un ejemplo:

usar std :: mem;
fn main ()
println!("Tamaño de Bool: byte", mem :: size_of ::());
println!("Tamaño del número entero sin firmar de 8 bits: byte", mem :: size_of ::());
println!("Tamaño del número entero sin firmar de 16 bits: bytes", mem :: size_of ::());
println!("Tamaño del número entero sin firmar de 32 bits: bytes", mem :: size_of ::());
println!("Tamaño del número entero sin firmar de 64 bits: bytes", mem :: size_of ::());
println!("Tamaño del número entero firmado de 8 bits: byte", mem :: size_of ::());
println!("Tamaño del número entero firmado de 16 bits: bytes", mem :: size_of ::());
println!("Tamaño del número entero firmado de 32 bits: bytes", mem :: size_of ::());
println!("Tamaño del número entero firmado de 64 bits: bytes", mem :: size_of ::());
println!("Tamaño del tipo flotante de 32 bits: bytes", mem :: size_of ::());
println!("Tamaño del tipo flotante de 64 bits: bytes", mem :: size_of ::());
println!("Tamaño del carácter: bytes", mem :: size_of ::());

El programa simple mencionado anteriormente determina el tamaño de todos los tipos primitivos en el lenguaje de óxido. Un ejemplo de salida resultante es como se muestra:

Tamaño de bool: 1 byte
Tamaño del entero sin firmar de 8 bits: 1 byte
Tamaño del número entero sin firmar de 16 bits: 2 bytes
Tamaño del entero sin firmar de 32 bits: 4 bytes
Tamaño del entero sin firmar de 64 bits: 8 bytes
Tamaño del número entero firmado de 8 bits: 1 byte
Tamaño del número entero firmado de 16 bits: 2 bytes
Tamaño del número entero firmado de 32 bits: 4 bytes
Tamaño del número entero firmado de 64 bits: 8 bytes
Tamaño del tipo flotante de 32 bits: 4 bytes
Tamaño del tipo flotante de 64 bits: 8 bytes
Tamaño del carácter: 4 bytes

Tamaño de óxido de la estructura

En el óxido, el tamaño de las estructuras está determinado por un algoritmo simple:

El algoritmo agrega el tamaño del campo en el orden de la declaración.
Redondea el tamaño al múltiplo más cercano de la alineación del siguiente campo.
Finalmente, el algoritmo redondea el tamaño de la estructura al múltiplo más cercano de su alineación.

Puede obtener más información sobre la alineación en el recurso proporcionado a continuación:

https: // doc.lang óxido.org/stable/std/mem/fn.alinearse.html

Un ejemplo del tamaño de una estructura es como se muestra a continuación:

Struct User
Nombre: cadena,
Edad: U32,
Correo electrónico: cadena,

fnmain ()
println!("Tamaño de la estructura: bytes", mem :: size_of: :())

El código anterior debe devolver el tamaño de la estructura como:

$ Cargo Run
Tamaño de la estructura: 56 bytes

Tamaño de óxido de la matriz

También podemos usar el método size_of para determinar el tamaño de una matriz. Considere el ejemplo proporcionado a continuación:

println!("El tamaño de la matriz es: bytes", mem :: size_of ::<[i32; 5]>())

El ejemplo anterior determina el tamaño de una matriz de tipos i32 y una longitud de 5. La matriz equivalente es como se muestra a continuación:

Deje my_array: [i32; 5] = [1,2,3,4,5];

El programa debe devolver el tamaño de la matriz como:

El tamaño de la matriz es: 20 bytes

Tamaño de óxido del puntero

El siguiente ejemplo evalúa el tamaño de un puntero utilizando la sintaxis:

println!("Tamaño del puntero bytes", mem :: size_of ::<*const i32>());

El código anterior devuelve el tamaño de un puntero sin procesar en una referencia de i32. La salida resultante se proporciona a continuación:

Tamaño de Pointer8 bytes

Conclusión

Este artículo describe cómo determinar el tamaño de varios tipos de óxido, incluidos tipos primitivos, matrices, punteros y estructuras. Además, la función size_of se discutió en detalle. Esperamos que hayas encontrado este artículo útil. Consulte el otro artículo de Sugerencia de Linux para obtener más consejos y artículos.

Potencia Shell

Cómo usar el cmdlet de movimiento de movimiento en PowerShell?

El cmdlet Move-Item mueve los archivos o carpetas de una ubicación a otra. Además, mueve elementos, ...

Mariana Cotto

Potencia Shell

Cómo usar el comando set-variable en PowerShell

El cmdlet set-variable establece o cambia el valor de una variable existente. Además, si la variable...

Lorenzo Morales

Programación C

Libros y guías para el lenguaje C

Hay 6 libros y guías útiles para aprender el idioma C. Siga este artículo para aprender en detalle s...

Pilar Melgar