Types primitifs composés

Ce guide est actuellement en cours de rédaction : si quelque chose vous semble mal expliqué ou peu clair, n'hésitez pas à me faire un retour sur github ou par mail

Une nouvelle feuille sera publiée chaque semaine : si vous souhaitez être averti·e des nouveaux contenus, abonnez-vous par mail ou suivez-moi sur twitter

Les types composés peuvent regrouper plusieurs valeurs dans un seul type. Rust propose deux types composés primitifs : les tuples et les arrays.

tuple

Créer un tuple composé de différents types primitifs :

let tup: (i32, f64, u8, String) = (500, 6.4, 1, String::from("Hello"));
1

L'inférence de type permet d'écrire plus simplement :

let tup = (500, 6.4, 1, String::from("Hello"));
1

Lire les valeurs du tuple :

let tup = (500, 6.4, 1, String::from("Hello"));

// affiche "6.4"
println!("{}", tup.1);

// affiche aussi "6.4"
let (x, y, z, hello) = tup;
println!("{}", y);
1
2
3
4
5
6
7
8

array

Contrairement au tuple, chaque élément d'un array doit être du même type.

let ids: [i32; 5] = [12, 16, 23, 15, 99];

// affiche "99'"
println!("{}", ids[4]);
1
2
3
4

L'inférence de type nous permet d'écrire plus simplement :

let ids = [12, 16, 23, 15, 99];

// affiche "99'"
println!("{}", ids[4]);
1
2
3
4

NOTA BENE

les arrays ont une longueur fixe : une fois déclaré, leur taille ne peut pas s'agrandir ou se réduire. On verra plus tard le type vectors dont la taille peut varier dynamiquement.