Exploration des types primitifs de Rust

Introduction

Dans ce laboratoire, vous allez découvrir les différents primitifs fournis par Rust, y compris les types scalaires tels que les entiers signés et non signés, les nombres à virgule flottante, les valeurs scalaires Unicode, les valeurs booléennes et le type unité. Vous allez également explorer les types composites tels que les tableaux et les tuples, et apprendre à annoter les variables avec leurs types respectifs ou à laisser Rust inférer les types à partir du contexte.

Note : Si le laboratoire ne spécifie pas de nom de fichier, vous pouvez utiliser n'importe quel nom de fichier que vous voulez. Par exemple, vous pouvez utiliser main.rs, le compiler et l'exécuter avec rustc main.rs &&./main.

Primitives

Rust fournit un accès à une grande variété de primitives. Voici un exemple :

Types scalaires

• Entiers signés : i8, i16, i32, i64, i128 et isize (taille de pointeur)
• Entiers non signés : u8, u16, u32, u64, u128 et usize (taille de pointeur)
• Nombres à virgule flottante : f32, f64
• Valeurs scalaires Unicode char telles que 'a', 'α' et '∞' (4 octets chacune)
• bool soit true soit false
• Le type unité (), dont la seule valeur possible est un tuple vide : ()

Malgré la valeur d'un type unité étant un tuple, il n'est pas considéré comme un type composé car il ne contient pas plusieurs valeurs.

Types composites

• Tableaux comme [1, 2, 3]
• Tuples comme (1, true)

Les variables peuvent toujours être annotées avec leur type. Les nombres peuvent également être annotés via un suffixe ou par défaut. Les entiers ont comme valeur par défaut i32 et les flottants f64. Notez que Rust peut également inférer les types à partir du contexte.

fn main() {
    // Les variables peuvent être annotées avec leur type.
    let logique: bool = true;

    let un_flottant: f64 = 1.0;  // Annotation classique
    let un_entier   = 5i32; // Annotation avec suffixe

    // Ou une valeur par défaut sera utilisée.
    let flottant_par_defaut   = 3.0; // `f64`
    let entier_par_defaut = 7;   // `i32`

    // Un type peut également être inferé à partir du contexte.
    let mut type_inferé = 12; // Le type i64 est inferé à partir d'une autre ligne.
    type_inferé = 4294967296i64;

    // La valeur d'une variable mutable peut être changée.
    let mut mutable = 12; // `i32` mutable
    mutable = 21;

    // Erreur! Le type d'une variable ne peut pas être changé.
    mutable = true;

    // Les variables peuvent être écrasées par ombre.
    let mutable = true;
}

Résumé

Félicitations! Vous avez terminé le laboratoire Primitives. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.