Rust - from Mozilla

Array statici          

Come in molti altri linguaggi, un array in Rust è un collezione finita di elementi dello stesso tipo ognuno dei quali è individuabile attraverso un indice. Definizione classica, del tutto simile a quanto si incontra in altri linguaggi. Gli elementi sono memorizzati in maniera contigua in memoria. Iniziamo a parlare del tipo più semplice,
gli array statici,
le cui dimensioni cioè non possono variare nel corso del programma
. La  definizione formale è molto semplice e la vediamo con alcuni esempi:

1) let x1 = [1,2,3,4,5];
2) let x2 : [int32; 5] = [1,2,3,4,5];

le due definizioni sono uguali, la prima acquisisce il tipo per inferenza mentre le dimensioni sono fornite dal numero degli elementi stessi. Come si vede,
- gli elementi costitutivi dell'array si trovano all'interno di una coppia di parentesi quadre
.
Va inoltre segnalato che:
- gli in array in Rust sono 0-based, ovvero il primo indice è 0, gli altri seguono in progressione aritmetica
.

  Esempio 8.1
1
2
3
4
5
6
7
8
fn main()
{
  let x1 = [1,2,3,4,5];
  let x2 : [i32; 5];
  x2 = [7,8,9,10,11];
  println!("{}", x1[0]);
  println!("{}", x2[0]);
}

Non esiste inizializzazione di default. Se, ad esempio, eliminate la riga 5 dall'esempio 8.1 il compilatore si lamenterà per l'istruzione presente alla riga 7:

error: use of possibly uninitialized variable: `x2[..]` [E0381]

Le righe 6 e 7 ci indicano anche il modo, consueto nel mondo della programmazione, per accedere ad un elemento di un array, ovvero usando l'operatore [].

Esiste il modo per inizializzare un array con uno stesso valore in un'unica istruzione:

let x2 : [i32; 5] = [4; 5];

Questa riga genera un array di nome x2 contenente 5 elementi ognuno dei quali ha valore 4.
Per conoscere le dimensioni di un array possiamo ricorrere al metodo len();

println!("{}", x2.len());

Modificare il valore di un elemento di un array si ottiene accedendo all'elemento stesso con il solito []. Tuttavia non dimenticate che l'array stesso deve essere dichiarato mut, se no è immutabile, come ovvio.

  Esempio 8.2
1
2
3
4
5
6
7
fn main()
{
  let mut x2 : [i32; 5] = [4; 5];
  println!("{}", x2[2]);
  x2[2] = 9;
  println!("{}", x2[2]);
}

Iterare sugli elementi di un array è possibile in modo per così dire classico:

let x01 = [1,2,3,4,5];
for i in 0..x01.len()
{
  print!("{},", x01[i])
}

oppure utilizzando iter():

let x01 = [1,2,3,4,5];
for i in x01.iter()
{
  print!("{},", i)
}

Che restituisce lo stesso output del frammento di codice precedente.

Per copiare un array in un altro potete ricorre a clone(), oltre ai soliti metodi  iterativi elemento per elemento:

  Esempio 8.3
1
2
3
4
5
6
7
8
fn main()
{
  let x1 = [1,2,3,4,5];
  let x2 : [i32; 5];
  x2 = x1.clone();
  println!("{}", x1[0]);
  println!("{}", x2[0]);
}

Interessanti anche due rapidi sistemi per lavorare sugli array:

sort() che permette di ordinare in ordine crescente gli elementi, se ordinabili
reverse() che rovescia l'ordine degli elementi

let mut x1 = [7,12,0,2,8];
x1.sort()
x1.reverse();

Queste istruzioni ordinano in senso inverso (dal più grande al più piccolo) gli elementi dell'array x1.

Quanto visto in questo paragrafo va bene come base di lavoro. Nel prossimo paragrafo vedremo i più interessanti array dinamici.