Tableaux et Tuples en Rust

Dans le post précédent, vous avez découvert les types de données Scalar dans Rust. Ce sont des nombres entiers, des virgules flottantes, des caractères et des booléens.

Dans cet article, nous examinerons les types de données Compound dans le langage de programmation Rust.

Qu’est-ce qu’un type de données composé dans Rust ?

Les types de données composés peuvent stocker plusieurs valeurs dans une variable. Ces valeurs peuvent être soit du même type de données scalaires, soit de types scalaires différents.

Le langage de programmation Rust possède deux types de données :

• Tableaux: stocke plusieurs valeurs du même type.
• Tuples: stocke plusieurs valeurs, soit du même type, soit même de types différents.

Alors regardons-les !

Tableaux en Rust

Les tableaux du langage de programmation Rust ont les propriétés suivantes :

• Chaque élément doit avoir le même type
• Les tableaux ont une longueur fixe
• Les tableaux sont stockés dans la pile, c’est-à-dire que les données qui y sont stockées sont accessibles rapidement

La syntaxe pour créer un tableau est la suivante :

// without type annotation
let variable_name = [element1, element2, ..., elementn];

// with type annotation
let variable_name: [data_type; array_length] = [element1, element2, ..., elementn];

Les éléments d’un tableau sont déclarés entre crochets. Pour accéder à un élément d’un tableau, l’index auquel accéder est spécifié entre crochets.

Regardons un exemple de programme pour mieux comprendre cela.

fn main() {
    // without type annotation
    let greeting = ['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!'];

    // with type annotation
    let pi: [i32; 10] = [1, 4, 1, 5, 9, 2, 6, 5, 3, 5];

    for character in greeting {
        print!("{}", character);
    }

    println!("\nPi: 3.1{}{}{}{}", pi[0], pi[1], pi[2], pi[3]);
}

Ici, je définis un tableau de caractères et un autre tableau qui stocke i32 tape dedans. Le greeting array contient les caractères de la chaîne “Hello world!” stockées en tant que caractères individuels. Le tableau pi a les 10 premières valeurs de Pi après les valeurs décimales qui y sont stockées sous forme de nombres individuels.

J’imprime ensuite chaque caractère du greeting tableau à l’aide de la for boucle. (Je vais entrer dans des boucles très bientôt.) Ensuite, j’imprime les 4 premières valeurs du pi déployer.

Hello world!
Pi: 3.11415

Si vous souhaitez créer un tableau où chaque élément est y et se produit X plusieurs fois, vous pouvez le faire dans Rust avec le raccourci suivant :

let variable_name = [y; x];

Regardons une démonstration…

fn main() {
    let a = [10; 5];

    for i in a {
        print!("{i} ");
    }
    println!("");
}

je crée une variable a qui sera de longueur 5. Chaque élément de ce tableau sera ’10’. Je vérifie cela en imprimant chaque élément du tableau en utilisant le for boucle.

Il a la sortie suivante :

10 10 10 10 10

Tuples dans Rust

Un Tuple dans le langage de programmation Rust a les propriétés suivantes :

• Les tuples, comme les tableaux, ont une longueur fixe
• Les éléments peuvent être de types de données scalaires identiques/différents
• Le Tuple est stocké sur la pile, c’est-à-dire un accès plus rapide

La syntaxe pour créer un tuple est la suivante :

// without type annotation
let variable_name = (element1, element2, ..., element3);

// with type annotation
let variable_name: (data_type, ..., data_type) = (element1, element2, ..., element3);

Les éléments d’un tuple sont écrits entre parenthèses. Pour accéder à un élément, l’opérateur point est utilisé et est suivi de l’indice dudit élément.

fn main() {
    let a = (38, 923.329, true);
    let b: (char, i32, f64, bool) = ('r', 43, 3.14, false);

    println!("a.0: {}, a.1: {}, a.2: {}", a.0, a.1, a.2);
    println!("b.0: {}, b.1: {}, b.2: {}, b.3: {}", b.0, b.1, b.2, b.3);

    // destructuring a tuple
    let pixel = (50, 0, 200);
    let (red, green, blue) = pixel;
    println!("red: {}, green: {}, blue: {}", red, green, blue);
}

Dans le code ci-dessus, aux lignes 2 et 3, je déclare deux tuples. Ceux-ci contiennent juste des valeurs aléatoires que j’ai inventées sur place. Mais regardez attentivement, le type de données de chaque élément dans les deux tuples est différent. Ensuite, aux lignes 5 et 6, j’imprime chaque élément des deux tuples.

A la ligne 9, je déclare un tuple appelé pixel qui a 3 éléments. Chaque élément est la magnitude des couleurs rouge, vert et bleu pour constituer un pixel. Cela va de 0 à 255. Donc, idéalement, j’annoterais le type à (u8, u8, u8) mais cette optimisation n’est pas nécessaire lors de l’apprentissage 😉

Puis, ligne 10, je “déstructure” chaque valeur du pixel tuple et stockez-le dans des variables individuelles red, green et blue. Ensuite, au lieu d’imprimer les valeurs des pixel tuple, j’imprime les valeurs du red, green et blue variables.

Voyons le rendu…

a.0: 38, a.1: 923.329, a.2: true
b.0: r, b.1: 43, b.2: 3.14, b.3: false
red: 50, green: 0, blue: 200

Cela me semble correct 🙂

Bonus : tranches

À proprement parler, les tranches ne sont pas un type de type de données composé dans Rust. Au contraire, une tranche est… un tranche d’un type de données composé existant.

Une tranche se compose de trois éléments :

1. Un indice de départ
2. L’opérateur de tranche (.. ou ..=)
3. Un index de fin

Voici un exemple d’utilisation d’une tranche d’un tableau.

fn main() {
    let my_array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let my_slice = &my_array[0..4];

    for element in my_slice {
        println!("{element}");
    }
}

Comme C et C++, l’esperluette est utilisée pour stocker la référence (au lieu d’un pointeur brut) d’une variable. Donc &my_array désigne une référence à la variable my_array.

Venons-en maintenant à la tranche. La tranche est désignée par le [0..4]. Ici, 0 est l’index de l’endroit où commencer la tranche. Et 4 est l’endroit où la tranche se termine. Le 4 ici est un index non inclusif.

Voici la sortie du programme pour mieux comprendre ce qui se passe :

0
1
2
3

Si vous voulez un compris plage, vous pouvez utiliser à la place ..= comme opérateur de tranche pour une plage inclusive.

fn main() {
    let my_array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let my_slice = &my_array[0..=4];

    for element in my_slice {
        println!("{element}");
    }
}

Maintenant, cette plage va de 0^e élément au 4^e element et ci-dessous est la sortie pour prouver que:

0
1
2
3
4

Conclusion

Cet article sur le langage de programmation Rust couvre les types de données composés en profondeur. Vous avez appris à déclarer et à accéder aux valeurs stockées dans les types Array et Tuple. De plus, vous avez examiné le “type” Slice et également comment déstructurer un tuple.

Dans le chapitre suivant, vous apprendrez à utiliser les fonctions dans les programmes Rust. Restez à l’écoute.