Rust Basics Series #3 : Types de données dans Rust

Dans l’article précédent sur le langage de programmation Rust, nous avons examiné les variables, les constantes et l’ombrage.

Il est naturel de couvrir les types de données maintenant.

Que sont les types de données ?

Changez l’ordre de ces mots et vous obtenez votre réponse ; “types de données” -> “type de données”.

L’ordinateur stocke les données sous forme 0sable 1s mais pour donner un sens à la lecture, nous utilisons le type de données pour dire ce que ces 0sable 1c’est dire.

Rust a deux types de types de données :

1. Type de données scalaire: Types qui ne stockent qu’une seule valeur.
2. Type de données composé: Types qui stockent plusieurs valeurs, même des valeurs de types différents.

Dans cet article, je couvrirai les types de données scalaires. Je vais passer par la deuxième catégorie dans le prochain article.

Voici un bref aperçu des quatre principales catégories de types de données scalaires dans Rust :

• Entiers: Enregistre les nombres entiers. Possède des sous-types pour chaque cas d’utilisation spécifique.
• Flotteurs: stocke les nombres avec une valeur fractionnaire. A deux sous-types basés sur la taille.
• Personnages: stocke un seul caractère d’encodage UTF-8. (Oui, vous pouvez stocker un emoji* dans un personnage.)
• Booléens: Stocke soit un true ou un false. (Pour les développeurs qui ne sont pas d’accord si 0 est true ou si 0 moyens false.)

Entiers

Un nombre entier dans le contexte d’un langage de programmation fait référence à des nombres entiers. Les entiers dans Rust sont soit Signé ou Non signé. Les entiers non signés ne stockent que des nombres 0 et positifs, tandis que les entiers signés peuvent stocker des nombres négatifs, 0 et des nombres positifs.

Voici les types d’entiers disponibles en fonction du signe et de la longueur :

Comme vous pouvez le voir, Rust a des entiers signés et non signés de longueur 8, 16, 32, 64 et même 128 !

Les entiers avec *size varient en fonction de l’architecture de l’ordinateur. Sur les microcontrôleurs 8 bits, il est *8sur les anciens ordinateurs 32 bits, il est *32 et sur les systèmes 64 bits modernes, il est *64.

L’utilisation de *size est de stocker des données qui sont principalement liées à la mémoire (qui dépend de la machine), comme les pointeurs, les décalages, etc.

Rust vous permet non seulement de stocker des nombres entiers sous leur forme décimale, mais également sous les formes binaire, octale et hexadécimale.

Pour une meilleure lisibilité, vous pouvez utiliser le trait de soulignement _ en remplacement des virgules dans l’écriture/lecture de grands nombres.

fn main() {
    let bin_value = 0b100_0101; // use prefix '0b' for Binary representation
    let oct_value = 0o105; // use prefix '0o' for Octals
    let hex_value = 0x45; // use prefix '0x' for Hexadecimals
    let dec_value = 1_00_00_000; // same as writing 1 Crore (1,00,00,000)

    println!("bin_value: {bin_value}");
    println!("oct_value: {oct_value}");
    println!("hex_value: {hex_value}");
    println!("dec_value: {dec_value}");
}

J’ai stocké le nombre décimal 69 sous forme binaire, octale et hexadécimale dans les variables bin_value, oct_value et hex_value respectivement. Dans la variable dec_value, j’ai stocké le nombre 1 Crore (10 millions) et j’ai des virgules avec des traits de soulignement, selon le système de numérotation indien. Pour ceux qui sont plus familiers avec le système de numérotation international, vous pouvez écrire ceci comme 10_000_000.

Lors de la compilation et de l’exécution de ce binaire, j’obtiens la sortie suivante :

bin_value: 69
oct_value: 69
hex_value: 69
dec_value: 10000000

Nombres à virgule flottante

Les nombres à virgule flottante, ou plus communément appelés “float(s)”, sont un type de données qui contient des nombres qui ont une valeur fractionnaire (quelque chose après la virgule décimale).

Contrairement au type Integer dans Rust, les nombres à virgule flottante n’ont que deux types de sous-ensemble :

• f32: Type virgule flottante simple précision
• f64: Type virgule flottante double précision

Comme le type Integer dans Rust, lorsque Rust déduit le type d’une variable qui ressemble à un flottant, on lui attribue le f64 taper. C’est parce que le f64 le type a plus de précision que le f32 type et est presque aussi rapide que le f32 type dans la plupart des opérations de calcul. Veuillez noter que les deux types de données à virgule flottante (f32 et f64) sont Signé.

fn main() {
    let pi: f32 = 3.1400; // f32
    let golden_ratio = 1.610000; // f64
    let five = 5.00; // decimal point indicates that it must be inferred as a float
    let six: f64 = 6.; // even the though type is annotated, a decimal point is still
                       // **necessary**

    println!("pi: {pi}");
    println!("golden_ratio: {golden_ratio}");
    println!("five: {five}");
    println!("six: {six}");
}

Regardez bien le 5^e doubler. Même si j’ai annoté le type de la variable sixJE besoin d’utiliser au moins la virgule décimale. Si vous avez quelque chose après la virgule décimale dépend de vous.

La sortie de ce programme est assez prévisible… Ou est-ce le cas ?

pi: 3.14
golden_ratio: 1.61
five: 5
six: 6

Dans la sortie ci-dessus, vous avez peut-être remarqué que lors de l’affichage de la valeur stockée dans les variables pi, golden_ratio et fiveles zéros de fin que j’ai spécifiés au moment de la déclaration de la variable sont manquants.

Bien que ces zéros ne soient pas suppriméils sont omis lors de la sortie des valeurs via le println macro. Donc non, Rust n’a pas altéré les valeurs de votre variable.

Personnages

Vous pouvez stocker un seul caractère dans une variable et le type est simplement char. Comme les langages de programmation traditionnels des années 80, vous pouvez stocker un caractère ASCII. Mais Rust étend également le type de caractère pour stocker un caractère UTF-8 valide. Cela signifie que vous pouvez stocker un emoji dans un seul caractère 😉

fn main() {
    let a="a";
    let p: char="p"; // with explicit type annotation
    let crab = '🦀';

    println!("Oh look, {} {}! :{}", a, crab, p);
}

Comme vous pouvez le voir, j’ai stocké les caractères ASCII ‘a’ et ‘p’ dans des variables a et p. Je stocke également un caractère UTF-8 valide, l’emoji crabe, dans la variable crab. J’imprime ensuite les caractères stockés dans chacune de ces variables.

Voici la sortie :

Oh look, a 🦀! :p

Booléens

Le type booléen de Rust ne stocke qu’une des deux valeurs possibles : soit true ou false. Si vous souhaitez annoter le type, utilisez bool pour indiquer le type.

fn main() {
    let val_t: bool = true;
    let val_f = false;

    println!("val_t: {val_t}");
    println!("val_f: {val_f}");
}

Le code ci-dessus, lorsqu’il est compilé et exécuté, donne le résultat suivant :

val_t: true
val_f: false

Bonus : transtypage explicite

Dans l’article précédent sur les variables dans le langage de programmation Rust, j’ai montré un programme de conversion de température très basique. Là-dedans, j’ai mentionné que Rust n’autorise pas le transtypage implicite.

Mais cela ne signifie pas que Rust ne permet pas explicite transtypage non plus 😉

Pour effectuer un casting de type explicite, le as mot-clé est utilisé et suivi du type de données dans lequel la valeur doit être convertie.

Voici un programme de démonstration :

fn main() {
    let a = 3 as f64; // f64
    let b = 3.14159265359 as i32; // i32

    println!("a: {a}");
    println!("b: {b}");
}

Sur la ligne 2, au lieu d’utiliser ‘3.0’, je fais suivre le ‘3’ avec as f64 pour indiquer que je veux que le compilateur gère la conversion de type de ‘3’ (un entier) en un flottant 64 bits. Idem avec les 3^rd doubler. Mais ici, le casting de type est avec perte. Ce qui signifie que l’élément fractionnaire est complètement disparu. Au lieu de stocker 3.14159265359il est stocké aussi simplement 3.

Cela peut être vérifié à partir de la sortie du programme :

a: 3
b: 3

Conclusion

Cet article couvre les types de données Primitive/Scalar dans Rust. Il existe principalement quatre types de données : entiers, nombres à virgule flottante, caractères et booléens.

Les nombres entiers sont utilisés pour stocker des nombres entiers et ils ont plusieurs sous-types basés sur le fait qu’ils sont signés ou non signés et la longueur. Les nombres à virgule flottante sont utilisés pour stocker des nombres avec des valeurs fractionnaires et ont deux sous-types basés sur la longueur. Le type de données caractère est utilisé pour stocker un seul caractère encodé UTF-8 valide. Enfin, les booléens sont utilisés pour stocker soit un true ou false valeur.

Dans le chapitre suivant, j’aborderai les types de données composés comme les tableaux et les tuples. Restez à l’écoute.