Comment utiliser la fonction size_of dans la rouille

Pauline Giraud

Dans Rust, nous pouvons déterminer la taille d'un type spécifique en utilisant la fonction size_of. Cette fonction est dans Core :: mem :: size_of et prend un type et renvoie sa taille en octets.

Laissez-nous apprendre à utiliser la fonction size_of pour déterminer la taille de différents types dans la rouille.

Taille de la rouille des types primitifs

Nous pouvons déterminer la taille des types primitifs de rouille en utilisant la fonction size_of. La syntaxe générale de la fonction size_of est comme indiqué ci-dessous:

Pub const fn size_of()

Comme mentionné, la fonction renverra la taille du type spécifié en octets. La rouille indique que la taille d'un type n'est pas stable en compilations croisées, sauf pour les types primitifs.

Utilisez l'exemple suivant pour déterminer la taille d'un type booléen:

Utilisez Std :: mem;
fn main ()
println!("Taille de bool: octet", mem :: size_of ::());

L'exemple de programme importe le module de mémoire de la bibliothèque standard. Cela nous donne accès à la fonction size_of pour déterminer la taille d'un bool.

Ensuite, nous appelons la fonction à l'intérieur de la méthode println et retournons la taille d'un type booléen.

La sortie résultante est comme indiqué ci-dessous:

$ cargo Run
Taille de Bool: 1 octet

Nous pouvons le faire pour tous les autres types primitifs de rouille. Un exemple est fourni ci-dessous:

Utilisez Std :: mem;
fn main ()
println!("Taille de bool: octet", mem :: size_of ::());
println!("Taille d'un entier non signé 8 bits: octet", mem :: size_of ::());
println!("Taille d'un entier non signé 16 bits: octets", mem :: size_of ::());
println!("Taille d'un entier non signé 32 bits: octets", mem :: size_of ::());
println!("Taille d'un entier non signé 64 bits: octets", mem :: size_of ::());
println!("Taille de 8 bits signés entier: octet", mem :: size_of ::());
println!("Taille d'un entier signé 16 bits: octets", mem :: size_of ::());
println!("Taille de 32 bits signés entier: octets", mem :: size_of ::());
println!("Taille de 64 bits signés entier: octets", mem :: size_of ::());
println!("Taille de type flottant 32 bits: octets", mem :: size_of ::());
println!("Taille de type flottant 64 bits: octets", mem :: size_of ::());
println!("Taille du caractère: octets", mem :: size_of ::());

Le programme simple mentionné ci-dessus détermine la taille de tous les types primitifs dans le langage de la rouille. Un exemple de sortie résultant est comme indiqué:

Taille de Bool: 1 octet
Taille d'un entier non signé 8 bits: 1 octet
Taille d'un entier non signé 16 bits: 2 octets
Taille d'un entier non signé 32 bits: 4 octets
Taille d'un entier non signé 64 bits: 8 octets
Taille d'un entier signé 8 bits: 1 octet
Taille d'un entier signé 16 bits: 2 octets
Taille de 32 bits signés entier: 4 octets
Taille de 64 bits signés entier: 8 octets
Taille de type flottant 32 bits: 4 octets
Taille de type flottant 64 bits: 8 octets
Taille du caractère: 4 octets

Taille de la rouille de la structure

Dans la rouille, la taille des structures est déterminée par un algorithme simple:

L'algorithme ajoute la taille du champ dans l'ordre de déclaration.
Il rassemble la taille du multiple le plus proche de l'alignement du champ suivant.
Enfin, l'algorithme arrond la taille de la structure au multiple le plus proche de son alignement.

Vous pouvez en savoir plus sur l'alignement de la ressource ci-dessous:

https: // doc.chanteur de la rouille.org / stable / std / mem / fn.align_of.html

Un exemple de la taille d'une structure est comme indiqué ci-dessous:

Struct User
nom: chaîne,
Âge: U32,
Email: chaîne,

fnmain ()
println!("Taille de la structure: octets", mem :: size_of: :())

Le code précédent doit renvoyer la taille de la structure comme:

$ cargo Run
Taille de la structure: 56 octets

Taille de la rouille du tableau

Nous pouvons également utiliser la méthode size_of pour déterminer la taille d'un tableau. Considérez l'exemple fourni ci-dessous:

println!("La taille du tableau est: octets", mem :: size_of ::<[i32; 5]>())

L'exemple précédent détermine la taille d'un tableau de types i32 et une longueur de 5. Le tableau équivalent est comme indiqué ci-dessous:

Laissez mon_array: [i32; 5] = [1,2,3,4,5];

Le programme doit renvoyer la taille du tableau comme:

La taille du tableau est: 20 octets

Taille de la rouille du pointeur

L'exemple suivant évalue la taille d'un pointeur à l'aide de la syntaxe:

println!("Taille du pointeur octets", mem :: size_of ::<*const i32>());

Le code précédent renvoie la taille d'un pointeur brut dans une référence i32. La sortie résultante est fournie ci-dessous:

Taille des octets Pointer8

Conclusion

Cet article décrit comment déterminer la taille de différents types de rouille, y compris les types primitifs, les tableaux, les pointeurs et les structures. De plus, la fonction size_of a été discutée en détail. Nous espérons que vous avez trouvé cet article utile. Consultez l'article de l'autre indice de Linux pour plus de conseils et d'articles.

php

Qu'est-ce qu'une interface dans PHP orienté objet

Les interfaces définissent un ensemble standard d'actions que diverses classes peuvent utiliser pour...

Mélissa Vincent

Powershell

Comment fonctionne la commande «Get-Process» dans PowerShell

Le CMDLETLLE Get-Process dans PowerShell obtient le processus en cours d'exécution sur les ordinateu...

Gabriel Bernard

C programmation C

Comment trier les tableaux avec QSort en C

QSORT est une fonction puissante dans la programmation C pour le tri des tableaux de tout type. Suiv...

Pauline Giraud