Come utilizzare la funzione size_of in ruggine

Dante Palumbo

In ruggine, possiamo determinare la dimensione di un tipo specifico usando la funzione size_of. Questa funzione è in core :: mem :: size_of e prende un tipo e restituisce le sue dimensioni in byte.

Impariamo come utilizzare la funzione size_of per determinare la dimensione di vari tipi in ruggine.

Dimensione della ruggine dei tipi primitivi

Possiamo determinare la dimensione dei tipi primitivi di ruggine usando la funzione size_of. La sintassi generale della funzione size_of è come mostrato di seguito:

pub const fn size_of()

Come accennato, la funzione restituirà la dimensione del tipo specificato in byte. Ruggine afferma che le dimensioni di un tipo non sono stabili nelle compilation incrociate ad eccezione dei tipi primitivi.

Usiamo il seguente esempio per determinare la dimensione di un tipo booleano:

Usa std :: mem;
fn main ()
println!("Dimensione di bool: byte", mem :: size_of ::());

Il programma di esempio importa il modulo di memoria dalla libreria standard. Questo ci dà accesso alla funzione size_of per determinare la dimensione di un bool.

Quindi, chiamiamo la funzione all'interno del metodo println e restituiamo le dimensioni di un tipo booleano.

L'output risultante è come mostrato di seguito:

$ cargo run
Dimensioni di bool: 1 byte

Possiamo farlo per tutti gli altri tipi primitivi in ruggine. Un esempio è fornito di seguito:

Usa std :: mem;
fn main ()
println!("Dimensione di bool: byte", mem :: size_of ::());
println!("Dimensione di intero senza segno a 8 bit: byte", mem :: size_of ::());
println!("Dimensione di intero senza segno a 16 bit: byte", mem :: size_of ::());
println!("Dimensione di intero senza segno a 32 bit: byte", mem :: size_of ::());
println!("Dimensione di intero senza segno a 64 bit: byte", mem :: size_of ::());
println!("Dimensione di intero firmato a 8 bit: byte", mem :: size_of ::());
println!("Dimensione di intero firmato a 16 bit: byte", mem :: size_of ::());
println!("Dimensione di intero firmato a 32 bit: byte", mem :: size_of ::());
println!("Dimensione di intero firmato a 64 bit: byte", mem :: size_of ::());
println!("Dimensione di tipo galleggiante a 32 bit: byte", mem :: size_of ::());
println!("Dimensione di tipo mobile a 64 bit: byte", mem :: size_of ::());
println!("Dimensione del carattere: byte", mem :: size_of ::());

Il semplice programma semplice sopra menzionato determina la dimensione di tutti i tipi primitivi nel linguaggio della ruggine. Un esempio che risulta l'output è come mostrato:

Dimensioni di bool: 1 byte
Dimensione di intero senza segno a 8 bit: 1 byte
Dimensione di intero non firmato a 16 bit: 2 byte
Dimensione di intero non firmato a 32 bit: 4 byte
Dimensione di intero senza segno a 64 bit: 8 byte
Dimensione di intero firmato a 8 bit: 1 byte
Dimensione di intero firmato a 16 bit: 2 byte
Dimensione di intero firmato a 32 bit: 4 byte
Dimensione di intero firmato a 64 bit: 8 byte
Dimensione di tipo galleggiante a 32 bit: 4 byte
Dimensione di tipo galleggiante a 64 bit: 8 byte
Dimensione del carattere: 4 byte

Dimensione della ruggine della struttura

In ruggine, la dimensione delle strutture è determinata da un semplice algoritmo:

L'algoritmo aggiunge le dimensioni del campo nell'ordine di dichiarazione.
Raccoglie le dimensioni al multiplo più vicino dell'allineamento del campo successivo.
Infine, l'algoritmo arrotonda le dimensioni della struttura al multiplo più vicino del suo allineamento.

Puoi saperne di più sull'allineamento nella risorsa fornita di seguito:

https: // doc.Rust-Lang.org/stabile/std/mem/fn.align_of.html

Un esempio della dimensione di una struttura è come mostrato di seguito:

utente struct
Nome: String,
Età: U32,
Email: stringa,

fnMain ()
println!("Dimensione della struttura: byte", mem :: size_of ::())

Il codice precedente dovrebbe restituire le dimensioni della struttura come:

$ cargo run
Dimensione della struttura: 56 byte

Dimensione della ruggine dell'array

Possiamo anche usare il metodo size_of per determinare la dimensione di un array. Considera l'esempio fornito di seguito:

println!("La dimensione dell'array è: byte", mem :: size_of ::<[i32; 5]>())

L'esempio precedente determina la dimensione di un array di tipi i32 e una lunghezza di 5. L'array equivalente è come mostrato di seguito:

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

Il programma dovrebbe restituire le dimensioni dell'array come:

La dimensione dell'array è: 20 byte

Dimensione della ruggine del puntatore

Il seguente esempio valuta la dimensione di un puntatore usando la sintassi:

println!("Dimensione del puntatore byte", mem :: size_of ::<*const i32>());

Il codice precedente restituisce la dimensione di un puntatore grezzo in un riferimento i32. L'output risultante è fornito di seguito:

Dimensione del puntatore8 byte

Conclusione

Questo articolo descrive come determinare la dimensione di vari tipi in ruggine, inclusi tipi primitivi, array, puntatori e strutture. Inoltre, la funzione size_of è stata discussa in dettaglio. Speriamo che tu abbia trovato questo articolo utile. Controlla l'altro articolo di Linux suggerimenti per ulteriori suggerimenti e articoli.

C ++

Differenza tra privato e protetto in C ++

Accesso privato Specificatore limita la visibilità dei membri della classe solo alla classe stessa. ...

Sig. Valdo Marchetti

c affilato

Quali sono le sequenze di fuga in C#

La sequenza di fuga in C# è una sequenza di caratteri che rappresenta un significato speciale se usa...

Dante Palumbo

PHP

Cos'è un'interfaccia in PHP orientato agli oggetti

Le interfacce definiscono un insieme standard di azioni che varie classi possono utilizzare per cost...

Sig. Valdo Marchetti