Rouille - Réseau
Dans ce chapitre, nous allons découvrir un tableau et les différentes fonctionnalités qui lui sont associées. Avant d'en apprendre davantage sur les tableaux, voyons en quoi un tableau est différent d'une variable.
Les variables ont les limitations suivantes -
Les variables sont de nature scalaire. En d'autres termes, une déclaration de variable ne peut contenir qu'une seule valeur à la fois. Cela signifie que pour stocker n valeurs dans un programme, n déclaration de variable sera nécessaire. Par conséquent, l'utilisation de variables n'est pas faisable lorsque l'on a besoin de stocker une plus grande collection de valeurs.
Les variables d'un programme se voient allouer de la mémoire dans un ordre aléatoire, ce qui rend difficile la récupération / lecture des valeurs dans l'ordre de leur déclaration.
Un tableau est une collection homogène de valeurs. En termes simples, un tableau est une collection de valeurs du même type de données.
Caractéristiques d'une baie
Les caractéristiques d'un tableau sont énumérées ci-dessous -
Une déclaration de tableau alloue des blocs de mémoire séquentiels.
Les tableaux sont statiques. Cela signifie qu'un tableau une fois initialisé ne peut pas être redimensionné.
Chaque bloc de mémoire représente un élément de tableau.
Les éléments du tableau sont identifiés par un entier unique appelé indice / index de l'élément.
Le remplissage des éléments du tableau est appelé initialisation du tableau.
Les valeurs des éléments de tableau peuvent être mises à jour ou modifiées mais ne peuvent pas être supprimées.
Déclaration et initialisation de tableaux
Utilisez la syntaxe ci-dessous pour déclarer et initialiser un tableau dans Rust.
Syntaxe
//Syntax1
let variable_name = [value1,value2,value3];
//Syntax2
let variable_name:[dataType;size] = [value1,value2,value3];
//Syntax3
let variable_name:[dataType;size] = [default_value_for_elements,size];Dans la première syntaxe, le type du tableau est déduit du type de données du premier élément du tableau lors de l'initialisation.
Illustration: matrice simple
L'exemple suivant spécifie explicitement la taille et le type de données du tableau. La syntaxe {:?} De la fonction println! () Est utilisée pour imprimer toutes les valeurs du tableau. La fonction len () est utilisée pour calculer la taille du tableau.
fn main(){
let arr:[i32;4] = [10,20,30,40];
println!("array is {:?}",arr);
println!("array size is :{}",arr.len());
}Production
array is [10, 20, 30, 40]
array size is :4Illustration: tableau sans type de données
Le programme suivant déclare un tableau de 4 éléments. Le type de données n'est pas spécifié explicitement lors de la déclaration de variable. Dans ce cas, le tableau sera de type entier. La fonction len () est utilisée pour calculer la taille du tableau.
fn main(){
let arr = [10,20,30,40];
println!("array is {:?}",arr);
println!("array size is :{}",arr.len());
}Production
array is [10, 20, 30, 40]
array size is :4Illustration: valeurs par défaut
L'exemple suivant crée un tableau et initialise tous ses éléments avec une valeur par défaut de -1 .
fn main() {
let arr:[i32;4] = [-1;4];
println!("array is {:?}",arr);
println!("array size is :{}",arr.len());
}Production
array is [-1, -1, -1, -1]
array size is :4Illustration: tableau avec boucle for
L'exemple suivant parcourt un tableau et imprime les index et leurs valeurs correspondantes. La boucle récupère les valeurs d'index 0 à 4 (index du dernier élément du tableau).
fn main(){
let arr:[i32;4] = [10,20,30,40];
println!("array is {:?}",arr);
println!("array size is :{}",arr.len());
for index in 0..4 {
println!("index is: {} & value is : {}",index,arr[index]);
}
}Production
array is [10, 20, 30, 40]
array size is :4
index is: 0 & value is : 10
index is: 1 & value is : 20
index is: 2 & value is : 30
index is: 3 & value is : 40Illustration: utilisation de la fonction iter ()
La fonction iter () récupère les valeurs de tous les éléments d'un tableau.
fn main(){
let arr:[i32;4] = [10,20,30,40];
println!("array is {:?}",arr);
println!("array size is :{}",arr.len());
for val in arr.iter(){
println!("value is :{}",val);
}
}Production
array is [10, 20, 30, 40]
array size is :4
value is :10
value is :20
value is :30
value is :40Illustration: tableau Mutable
Le mot clé mut peut être utilisé pour déclarer un tableau mutable. L'exemple suivant déclare un tableau mutable et modifie la valeur du deuxième élément du tableau.
fn main(){
let mut arr:[i32;4] = [10,20,30,40];
arr[1] = 0;
println!("{:?}",arr);
}Production
[10, 0, 30, 40]Passage de tableaux en tant que paramètres à des fonctions
Un tableau peut être passé par valeur ou par référence à des fonctions.
Illustration: Passer par valeur
fn main() {
let arr = [10,20,30];
update(arr);
print!("Inside main {:?}",arr);
}
fn update(mut arr:[i32;3]){
for i in 0..3 {
arr[i] = 0;
}
println!("Inside update {:?}",arr);
}Production
Inside update [0, 0, 0]
Inside main [10, 20, 30]Illustration: Passez par référence
fn main() {
let mut arr = [10,20,30];
update(&mut arr);
print!("Inside main {:?}",arr);
}
fn update(arr:&mut [i32;3]){
for i in 0..3 {
arr[i] = 0;
}
println!("Inside update {:?}",arr);
}Production
Inside update [0, 0, 0]
Inside main [0, 0, 0]Déclaration de tableau et constantes
Prenons l'exemple ci-dessous pour comprendre la déclaration et les constantes des tableaux.
fn main() {
let N: usize = 20;
let arr = [0; N]; //Error: non-constant used with constant
print!("{}",arr[10])
}Le compilateur entraînera une exception. En effet, la longueur d'un tableau doit être connue au moment de la compilation. Ici, la valeur de la variable "N" sera déterminée lors de l'exécution. En d'autres termes, les variables ne peuvent pas être utilisées pour définir la taille d'un tableau.
Cependant, le programme suivant est valide -
fn main() {
const N: usize = 20;
// pointer sized
let arr = [0; N];
print!("{}",arr[10])
}La valeur d'un identifiant précédé du mot clé const est définie au moment de la compilation et ne peut pas être modifiée à l'exécution. usize est de la taille d'un pointeur, donc sa taille réelle dépend de l'architecture pour laquelle vous compilez votre programme.