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


  • FrançaisFrançais


  • 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.

    💡

    La plage d’entiers signés commence à partir de -(2n-1) et cette plage se termine par (2n-1)-1. De même, la plage des entiers non signés commence à 0 et se termine par (2n)-1.

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

    Types de données entiers dans Rust

    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.

    💡

    Lorsque vous ne spécifiez pas explicitement un sous-ensemble du type Integer, le compilateur Rust déduira que son type est i32 par défaut. Évidemment, si la valeur est plus grande ou plus petite que ce que i32 peut tenir, le compilateur Rust sortira poliment une erreur et vous demandera d’annoter manuellement le type.


    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é.

    📋

    Le langage de programmation Rust stocke les nombres à virgule flottante conformément à la norme IEEE 754 de représentation et d’arithmétique des nombres à virgule flottante.
    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 5e 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 😉

    💡

    Certains emojis sont un mélange de deux emojis existants. Un bon exemple est l’emoji ‘Fiery Heart’ : ❤️‍🔥. Cet emoji est construit en combinant deux emojis à l’aide d’un menuisier à largeur nulle : ❤️ + 🔥 = ❤️‍🔥

    Stocker de tels emojis dans une seule variable Rust de type caractère n’est pas possible.

    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 3rd 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.

    Source

    La Rédaction

    L'équipe rédactionnnelle du site

    Pour contacter personnellement le taulier :

    Laisser un commentaire

    Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

    Copy code