Hvordan du bruker størrelsen_offunksjonen i rust

Simen Stensrud

I rust kan vi bestemme størrelsen på en spesifikk type ved hjelp av størrelse_ av -funksjonen. Denne funksjonen er i Core :: Mem :: Size_of og tar en type og returnerer størrelsen i byte.

La oss lære å bruke størrelsesfunksjonen for å bestemme størrelsen på forskjellige typer rust.

Ruststørrelse på primitive typer

Vi kan bestemme størrelsen på de rustprimitive typene ved å bruke størrelse_offunksjonen. Den generelle syntaks for størrelse_ av -funksjonen er som vist nedenfor:

pub const fn size_of()

Som nevnt vil funksjonen returnere størrelsen på den spesifiserte typen i byte. Rust sier at størrelsen på en type ikke er stabil i krysssamlinger bortsett fra primitive typer.

La oss bruke følgende eksempel for å bestemme størrelsen på en boolsk type:

Bruk std :: mem;
fn main ()
Println!("Størrelse på bool: byte", mem :: størrelse_of ::());

Eksempelprogrammet importerer minnemodulen fra standardbiblioteket. Dette gir oss tilgang til størrelse_offunksjonen for å bestemme størrelsen på en bool.

Deretter kaller vi funksjonen inne i Println -metoden og returnerer størrelsen på en boolsk type.

Den resulterende utgangen er som vist nedenfor:

$ Cargo Run
Størrelse på bool: 1 byte

Vi kan gjøre dette for alle andre primitive typer i rust. Et eksempel er gitt nedenfor:

Bruk std :: mem;
fn main ()
Println!("Størrelse på bool: byte", mem :: størrelse_of ::());
Println!("Størrelse på 8-bits usignert heltall: byte", mem :: size_of ::());
Println!("Størrelse på 16-bits usignert heltall: byte", mem :: størrelse_of ::());
Println!("Størrelse på 32-bits usignert heltall: byte", mem :: størrelse_of ::());
Println!("Størrelse på 64-bits usignert heltall: byte", mem :: størrelse_of ::());
Println!("Størrelse på 8-bits signert heltall: byte", mem :: size_of ::());
Println!("Størrelse på 16-bits signert heltall: byte", mem :: størrelse_of ::());
Println!("Størrelse på 32-bits signert heltall: byte", mem :: størrelse_of ::());
Println!("Størrelse på 64-bits signert heltall: byte", mem :: størrelse_of ::());
Println!("Størrelse på 32-bit flytende type: byte", mem :: størrelse_of ::());
Println!("Størrelse på 64-bit flytende type: byte", mem :: størrelse_of ::());
Println!("Størrelse på karakter: byte", mem :: størrelse_of ::());

Det ovennevnte enkle programmet bestemmer størrelsen på alle primitive typer i rustspråket. Et eksempel resulterende utgang er som vist:

Størrelse på bool: 1 byte
Størrelse på 8-bits usignert heltall: 1 byte
Størrelse på 16-bits usignert heltall: 2 byte
Størrelse på 32-bits usignert heltall: 4 byte
Størrelse på 64-bits usignert heltall: 8 byte
Størrelse på 8-bits signert heltall: 1 byte
Størrelse på 16-bits signert heltall: 2 byte
Størrelse på 32-bits signert heltall: 4 byte
Størrelse på 64-bits signert heltall: 8 byte
Størrelse på 32-bit flytende type: 4 byte
Størrelse på 64-bit flytende type: 8 byte
Størrelse på karakter: 4 byte

Ruststørrelse på strukturen

I rust bestemmes størrelsen på strukturer av en enkel algoritme:

Algoritmen legger til størrelsen på feltet i rekkefølgen av erklæring.
Det avrunder størrelsen til nærmeste multippel av neste felts justering.
Til slutt runder algoritmen størrelsen på strukturen til nærmeste multiplum av dens justering.

Du kan lære mer om justeringen i ressursen som er gitt nedenfor:

https: // doc.Rust-Lang.org/stabil/std/mem/fn.Align_of.html

Et eksempel på størrelsen på en struktur er som vist nedenfor:

struct bruker
Navn: Streng,
Alder: U32,
E -post: streng,

fnMain ()
Println!("Størrelsen på strukturen: byte", mem :: størrelse_of: :())

Den forrige koden skal returnere størrelsen på strukturen som:

$ Cargo Run
Størrelsen på strukturen: 56 byte

Ruststørrelse på matrisen

Vi kan også bruke metoden Size_OF for å bestemme størrelsen på en matrise. Tenk på eksemplet som er gitt nedenfor:

Println!("Størrelse på matrisen er: byte", mem :: størrelse_of ::<[i32; 5]>())

Det forrige eksemplet bestemmer størrelsen på en rekke i32 -typer og en lengde på 5. Den tilsvarende matrisen er som vist nedenfor:

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

Programmet skal returnere størrelsen på matrisen som:

Størrelsen på matrisen er: 20 byte

Ruststørrelse på pekeren

Følgende eksempel evaluerer størrelsen på en peker ved bruk av syntaks:

Println!("Størrelse på pekeren byte", mem :: størrelse_of ::<*const i32>());

Den forrige koden returnerer størrelsen på en rå peker i en i32 -referanse. Den resulterende utgangen er gitt nedenfor:

Størrelse på peker8 byte

Konklusjon

Denne artikkelen beskriver hvordan du kan bestemme størrelsen på forskjellige typer i rust, inkludert primitive typer, matriser, pekere og strukturer. Dessuten ble størrelse_offunksjonen diskutert i detalj. Vi håper du fant denne artikkelen nyttig. Sjekk den andre Linux -hint -artikkelen for flere tips og artikler.

Oracle Database

Java Database Connectivity med Oracle

For å koble Java med Oracle -databasen, last ned og konfigurere JDBC -driveren, angi tilkoblingsegen...

Simen Ødegård

C ++

Forskjell mellom+= og =+operatører i C ++

I C ++,+= tilfører en verdi til en variabel og tildeler resultatet, mens =+tildeler verdi før du leg...

Elias Krogh Svendsen

PHP

Hvordan bruke addSlashes -funksjon i PHP

AddSlashes () -funksjon i PHP legger til en tilbakeslag (\) før spesialtegn som sitater, apostrofer ...

Erik Røed