Come utilizzare la funzione size_of in ruggine
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_ofCome 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 runDimensioni 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 byteDimensione 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 structNome: 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 runDimensione 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 byteDimensione 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 byteConclusione
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.