Tableau d'impression de rouille

Un tableau fait référence à une collection d'éléments d'un type similaire stocké dans un emplacement de mémoire de connexion. Les tableaux sont fondamentaux dans la plupart des langages de programmation car ils fournissent une gestion des données connexes diversifiée et efficace.

Dans cet article, nous explorerons comment nous pouvons travailler avec des tableaux dans le langage de programmation de rouille.

Rust Créer un tableau

Dans Rust, nous créons un tableau utilisant une paire de crochets au format comme indiqué ci-dessous:

[T; N],

Où t représente le type d'éléments à stocker dans le tableau et n représente la taille du tableau. N'oubliez pas que la taille se réfère au nombre d'éléments qu'un tableau peut contenir.

Rust nous fournit deux méthodes principales pour créer un tableau:

1. Un tableau avec une liste d'éléments pendant la déclaration.
2. Répétez l'expression où un élément spécifié est répété un nombre spécifié d'éléments. La syntaxe du tableau de répétition est comme indiqué [n, x]. Cela crée un tableau des éléments x répétés n fois.

Rust Déclare et initialise le tableau

Il y a trois façons de déclarer et d'initialiser les tableaux de rouille.

Maintenant, discutons:

Tableau sans type de données ni taille

La première méthode pour déclarer un tableau consiste à créer un tableau sans type de données ni taille. Un exemple de syntaxe est fourni ci-dessous:

Soit arr = [1,2,3,4,5];

L'exemple précédent crée un tableau sans type ni taille. Pour obtenir la longueur du tableau, vous pouvez utiliser la fonction Len () intégrée.

fn main ()
Soit arr = [1,2,3,4,5];
println!("Longueur du tableau ", arrond.Len ());

L'exemple précédent doit renvoyer la longueur du tableau comme:

Longueur du tableau 5

Tableau avec type de données et taille

La prochaine méthode pour déclarer un tableau consiste à définir son type et la taille. Un exemple de syntaxe pour déclarer un tel tableau est comme indiqué ci-dessous:

Laissez Arr: [i32; 5] = [1,2,3,4,5];

La syntaxe précédente crée un tableau d'entiers signés 32 bits avec une longueur de 5. L'impression de la longueur du tableau doit retourner 5.

println!("Longueur du tableau ", arrond.Len ());
// 5

Tableau avec valeur par défaut

Vous pouvez également créer un tableau où tous les éléments d'un élément prennent une valeur par défaut prédéfinie.

La syntaxe est comme indiqué:

Laissez Array_name: [array_type; array_size] = [default_value; array_size];

Un exemple est comme indiqué:

Laissez Arr: [&str; 5] = ["a"; 5];

L'exemple précédent crée un tableau de type et Str avec la taille de 5. Ensuite, nous définissons une valeur par défaut comme «A» pour tous les éléments du tableau.

Tableau d'impression de rouille

Pour imprimer un tableau en rouille, nous utilisons l'opérateur 😕 à l'intérieur du println! fonction.

Un exemple est fourni ci-dessous:

fn main ()
Laissez Arr: [&str; 5] = ["a"; 5];
println!("Déployer :? ", arr);

Le code précédent imprime les éléments du tableau comme prévu ci-dessous:

Array [«a», «a», «a», «a», «a»]

Tableau de rouille itérer

Nous pouvons itérer sur l'index et les éléments d'un tableau à l'aide d'une boucle pour une boucle ou de la fonction ITER. Maintenant, discutons.

Pour itération de boucle

La méthode la plus courante d'itération d'un tableau consiste à utiliser une boucle pour. Un exemple de code est comme indiqué ci-dessous:

fn main ()
Laissez Arr: [i32; 5] = [1,2,3,4,5];
pour l'index dans 0… arr.Len ()
println!("index: , valeur: ", index, arr [index]);

L'exemple précédent utilise une boucle pour itérer l'index du tableau de l'index 0 à la longueur du tableau.

N'oubliez pas que l'indexation commence à l'index 0 en rouille.

Pour accéder à l'article stocké à un index spécifique, nous utilisons le nom du tableau et passons l'index à laquelle nous souhaitons accéder à l'intérieur d'une paire de supports carrés.

L'exécution du code précédent doit retourner:

Index: 0, valeur: 1
Index: 1, valeur: 2
Index: 2, valeur: 3
Index: 3, valeur: 4
Index: 4, valeur: 5

Méthode ITER RUST

Nous pouvons également utiliser la méthode ITER sur les éléments d'un tableau. Un exemple est fourni ci-dessous:

fn main ()
Laissez Arr: [i32; 5] = [1,2,3,4,5];
pour la valeur dans Arr.iter ()
println!("", valeur);

Le code précédent doit imprimer chaque élément dans le tableau comme indiqué ci-dessous:

1
--- tronqué ---
5

Tableaux mutables

Par défaut, les tableaux sont immuables. Cela signifie que vous ne pouvez pas modifier les éléments une fois définis. Pour créer un tableau mutable, vous pouvez ajouter le mot-clé MUT pendant la déclaration du tableau.

Un exemple est comme indiqué:

Laissez Mut Arr: [i32; 5] = [1,2,3,4,5];

Déclarer un tableau utilisant la syntaxe précédente vous permet de changer d'éléments dans le tableau.

Conclusion

Dans cet article, nous avons exploré comment nous pouvons déclarer et utiliser des tableaux dans le langage de programmation Rust. Il existe trois façons de déclarer et d'initialiser les tableaux, qui incluent un tableau sans type de données et taille, un tableau avec type de données et taille, et un tableau avec une valeur par défaut. Nous espérons que vous avez trouvé cet article utile. Vérifiez les autres articles sur les indices Linux pour plus de conseils et d'informations.