Ruggine - Array

In questo capitolo impareremo a conoscere un array e le varie funzionalità ad esso associate. Prima di conoscere gli array, vediamo in che modo un array è diverso da una variabile.

Le variabili hanno le seguenti limitazioni:

• Le variabili sono di natura scalare. In altre parole, una dichiarazione di variabile può contenere solo un singolo valore alla volta. Ciò significa che per memorizzare n valori in un programma sarà necessaria una dichiarazione di n variabili. Pertanto, l'uso di variabili non è fattibile quando è necessario memorizzare una raccolta di valori più ampia.

• Alle variabili in un programma viene allocata la memoria in ordine casuale, rendendo così difficile recuperare / leggere i valori nell'ordine della loro dichiarazione.

Un array è una raccolta omogenea di valori. In poche parole, un array è una raccolta di valori dello stesso tipo di dati.

Caratteristiche di un array

Le caratteristiche di un array sono elencate di seguito:

• Una dichiarazione di matrice alloca blocchi di memoria sequenziali.

• Gli array sono statici. Ciò significa che un array una volta inizializzato non può essere ridimensionato.

• Ogni blocco di memoria rappresenta un elemento dell'array.

• Gli elementi della matrice sono identificati da un numero intero univoco chiamato pedice / indice dell'elemento.

• Il popolamento degli elementi dell'array è noto come inizializzazione dell'array.

• I valori degli elementi della matrice possono essere aggiornati o modificati ma non possono essere eliminati.

Dichiarazione e inizializzazione di array

Usa la sintassi fornita di seguito per dichiarare e inizializzare un array in Rust.

Sintassi

//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];

Nella prima sintassi, il tipo dell'array viene dedotto dal tipo di dati del primo elemento dell'array durante l'inizializzazione.

Illustrazione: Simple Array

L'esempio seguente specifica in modo esplicito la dimensione e il tipo di dati della matrice. La sintassi {:?} Della funzione println! () Viene utilizzata per stampare tutti i valori nell'array. La funzione len () viene utilizzata per calcolare la dimensione dell'array.

fn main(){
   let arr:[i32;4] = [10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());
}

Produzione

array is [10, 20, 30, 40]
array size is :4

Illustrazione: array senza tipo di dati

Il seguente programma dichiara un array di 4 elementi. Il tipo di dati non è specificato esplicitamente durante la dichiarazione della variabile. In questo caso, l'array sarà di tipo integer. La funzione len () viene utilizzata per calcolare la dimensione dell'array.

fn main(){
   let arr = [10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());
}

Produzione

array is [10, 20, 30, 40]
array size is :4

Illustrazione: valori predefiniti

L'esempio seguente crea un array e inizializza tutti i suoi elementi con un valore predefinito di -1 .

fn main() {
   let arr:[i32;4] = [-1;4];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());
}

Produzione

array is [-1, -1, -1, -1]
array size is :4

Illustrazione: array con ciclo for

L'esempio seguente esegue un'iterazione su un array e stampa gli indici e i valori corrispondenti. Il ciclo recupera i valori dall'indice 0 a 4 (indice dell'ultimo elemento dell'array).

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]);
   }
}

Produzione

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 : 40

Illustrazione: utilizzo della funzione iter ()

La funzione iter () recupera i valori di tutti gli elementi in un array.

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);
   }
}

Produzione

array is [10, 20, 30, 40]
array size is :4
value is :10
value is :20
value is :30
value is :40

Illustrazione: array mutevole

La parola chiave mut può essere utilizzata per dichiarare un array modificabile. L'esempio seguente dichiara una matrice modificabile e modifica il valore del secondo elemento della matrice.

fn main(){
   let mut arr:[i32;4] = [10,20,30,40];
   arr[1] = 0;
   println!("{:?}",arr);
}

Produzione

[10, 0, 30, 40]

Passaggio di matrici come parametri alle funzioni

Un array può essere passato per valore o per riferimento a funzioni.

Illustrazione: Passa per valore

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);
}

Produzione

Inside update [0, 0, 0]
Inside main [10, 20, 30]

Illustrazione: passaggio per riferimento

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);
}

Produzione

Inside update [0, 0, 0]
Inside main [0, 0, 0]

Dichiarazione di matrice e costanti

Consideriamo un esempio fornito di seguito per comprendere la dichiarazione e le costanti dell'array.

fn main() {
   let N: usize = 20;
   let arr = [0; N]; //Error: non-constant used with constant
   print!("{}",arr[10])
}

Il compilatore genererà un'eccezione. Questo perché la lunghezza di un array deve essere nota in fase di compilazione. Qui, il valore della variabile "N" sarà determinato in fase di esecuzione. In altre parole, le variabili non possono essere utilizzate per definire la dimensione di un array.

Tuttavia, il seguente programma è valido:

fn main() {
   const N: usize = 20; 
   // pointer sized
   let arr = [0; N];

   print!("{}",arr[10])
}

Il valore di un identificatore con prefisso con la parola chiave const viene definito in fase di compilazione e non può essere modificato in fase di esecuzione. usize ha le dimensioni di un puntatore, quindi la sua dimensione effettiva dipende dall'architettura per cui stai compilando il programma.