So verwenden Sie die Size_of -Funktion in Rost

In Rost können wir die Größe eines bestimmten Typs unter Verwendung der Size_of -Funktion bestimmen. Diese Funktion ist in Core :: mem :: size_of und nimmt einen Typ und gibt seine Größe in Bytes zurück.

Lassen Sie uns lernen, wie Sie die Funktion Size_of verwenden, um die Größe verschiedener Typen in Rost zu bestimmen.

Rostgröße primitiver Typen

Wir können die Größe der Rostprimitiventypen anhand der Size_of -Funktion bestimmen. Die allgemeine Syntax der size_of -Funktion ist wie unten gezeigt:

Pub const fn size_of()

Wie bereits erwähnt, gibt die Funktion die Größe des angegebenen Typs in Bytes zurück. Rost gibt an, dass die Größe eines Typs in Kreuzkompikationen außer primitiven Typen nicht stabil ist.

Verwenden wir das folgende Beispiel, um die Größe eines Booleschen Typs zu bestimmen:

Verwenden Sie std :: mem;
fn main ()
println!("Größe von bool: byte", mem :: size_of ::());

Das Beispielprogramm importiert das Speichermodul aus der Standardbibliothek. Dies gibt uns Zugriff auf die size_of -Funktion, um die Größe eines Bools zu bestimmen.

Dann rufen wir die Funktion innerhalb der Println -Methode auf und geben die Größe eines booleschen Typs zurück.

Die resultierende Ausgabe ist wie unten gezeigt:

$ Frachtlauf
Größe von Bool: 1 Byte

Wir können dies für alle anderen primitiven Typen im Rost tun. Nachfolgend finden Sie ein Beispiel:

Verwenden Sie std :: mem;
fn main ()
println!("Größe von bool: byte", mem :: size_of ::());
println!("Größe von 8-Bit-Unsigned Ganzzahl: Byte", mem :: size_of ::());
println!("Größe von 16-Bit unsigned Ganzzahl: Bytes", mem :: size_of ::());
println!("Größe von 32-Bit unsigned Ganzzahl: Bytes", mem :: size_of ::());
println!("Größe von 64-Bit unsigned Ganzzahl: Bytes", mem :: size_of ::());
println!("Größe des 8-Bit-Signiernicht: Byte", mem :: size_of ::());
println!("Größe von 16-Bit signierter Ganzzahl: Bytes", mem :: size_of ::());
println!("Größe von 32-Bit signierter Ganzzahl: Bytes", mem :: size_of ::());
println!("Größe von 64-Bit signierter Ganzzahl: Bytes", mem :: size_of ::());
println!("Größe von 32-Bit-Gleittyp: Bytes", mem :: size_of ::());
println!("Größe von 64-Bit-schwimmender Typ: Bytes", mem :: size_of ::());
println!("Größe des Zeichens: Bytes", mem :: size_of ::());

Das oben genannte einfache Programm bestimmt die Größe aller primitiven Typen in der Rostsprache. Ein Beispiel, das sich daraus ergibt, ist wie gezeigt:

Größe von Bool: 1 Byte
Größe der 8-Bit-Unsigned Ganzzahl: 1 Byte
Größe von 16-Bit-Unsigned Ganzzahl: 2 Bytes
Größe von 32-Bit unsigned Ganzzahl: 4 Bytes
Größe von 64-Bit unsigned Ganzzahl: 8 Bytes
Größe der 8-Bit-Signiernähe: 1 Byte
Größe der 16-Bit-Signiernähe: 2 Bytes
Größe von 32-Bit-Signiernähe: 4 Bytes
Größe von 64-Bit-Signiernähe: 8 Bytes
Größe von 32-Bit-schwimmender Typ: 4 Bytes
Größe von 64-Bit-schwimmender Typ: 8 Bytes
Charaktergröße: 4 Bytes

Rostgröße der Struktur

In Rost wird die Größe der Strukturen durch einen einfachen Algorithmus bestimmt:

Der Algorithmus fügt die Größe des Feldes in der Reihenfolge der Deklaration hinzu.
Es rundet die Größe auf das nächste Vielfache der Ausrichtung des nächsten Feldes ab.
Schließlich rundet der Algorithmus die Größe der Struktur auf das nächste Vielfache seiner Ausrichtung ab.

Sie können mehr über die Ausrichtung in der unten angegebenen Ressource erfahren:

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

Ein Beispiel für die Größe einer Struktur ist wie unten gezeigt:

Struktur Benutzer
Name: Zeichenfolge,
Alter: U32,
E -Mail: Zeichenfolge,

fnmain ()
println!("Größe der Struktur: Bytes", mem :: size_of: :())

Der vorherige Code sollte die Größe der Struktur als:

$ Frachtlauf
Größe der Struktur: 56 Bytes

Rostgröße des Arrays

Wir können auch die Methode Size_of verwenden, um die Größe eines Arrays zu bestimmen. Betrachten Sie das unten angegebene Beispiel:

println!("Größe des Arrays ist: Bytes", mem :: size_of ::<[i32; 5]>())

Das vorherige Beispiel bestimmt die Größe eines Arrays von i32 -Typen und eine Länge von 5. Das äquivalente Array ist wie unten gezeigt:

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

Das Programm sollte die Größe des Arrays als:

Die Größe des Arrays beträgt: 20 Bytes

Rostgröße des Zeigers

Das folgende Beispiel bewertet die Größe eines Zeigers unter Verwendung der Syntax:

println!("Größe des Zeigers Bytes", mem :: size_of ::<*const i32>());

Der vorherige Code gibt die Größe eines Rohzeigers in einer i32 -Referenz zurück. Die resultierende Ausgabe ist unten angegeben:

Größe von Zeiger8 -Bytes

Abschluss

In diesem Artikel wird beschrieben. Außerdem wurde die Size_of -Funktion ausführlich besprochen. Wir hoffen, Sie haben diesen Artikel hilfreich gefunden. Weitere Tipps und Artikel finden Sie im anderen Linux -Hinweis -Artikel.

c scharf

Was sind konstante Variablen in C#

Eine konstante Variable ist eine Art von Variable, deren Wert während ihrer Definition festgelegt wi...

Fr. Chris Frisch

c scharf

Was ist der Unterschied zwischen int und doppelt in C#

Ganzzahlen (int) sind ganze Zahlen, was bedeutet, dass sie keine Dezimalpunkte haben. Doppel (doppel...

Prof. Dr. Julien Plank

Golang

Was ist eine Klasse und ein Objekt in Golang?

Go hat keine Klassen oder Objekte im klassischen Sinne. Stattdessen verwendet es Strukturen und Schn...

Mohamed Flore