Rust: variabili e tipi di dato

In questa lezione, iniziamo a lavorare con variabili e dati in linguaggio Rust. Essenzialmente, ci occuperemo di studiare due cose: i tipi di dato disponibili e la parola chiave let che utilizzeremo per dichiarare una variabile. Si tratta di costrutti presenti in tutti i principali linguaggi come Java e Python, anche se non sempre prevedono la medesima sintassi.

Cosa è una variabile

Per chi non fosse avvezzo alla programmazione diciamo subito che una variabile è una locazione in memoria finalizzata al salvataggio di un valore che consista in un dato da utilizzare o nel risultato di una elaborazione. Il programmatore deve rendere noto al suo ambiente di programmazione che ha bisogno di una variabile e per questo essa va dichiarata specificando il nome con cui la riconosceremo (non l'indirizzo di memoria ma un riferimento mnemonico più facile da comprendere per noi "umani") ed il tipo di informazione da inserirvi all'interno, il cosiddetto tipo di dato (un numero intero, un numero in virgola, una stringa, etc.).

Iniziamo a conoscere quindi i tipi di dato di Rust con una panoramica che si occupi non solo di elencarli ma anche, un po', di classificarli.

Tipi di dato

Rust offre una lunga serie di tipi di dato già impostati (scopriremo che sarà molto importante imparare a creare i nostri) che possiamo per lo più suddividere in scalari, ovvero formati da una singola informazione (un numero, un carattere, un valore booleano, etc.), e composti, articolati in più valori organizzati in una struttura dati.

I tipi scalari sono:

• numeri interi con segno: il nome del tipo di dato inizia con la lettera "i" seguita da un numero che indica la quantità di bit che descrivono l'informazione, avremo così a disposizione i tipi i8, i16, i32, i64, i128 nonché isize;
• numeri interi senza segno: il formato del loro nome segue la tipologia dei precedenti avendo la lettera "u" come iniziale al posto della "i", eccoli: u8, u16, u32, u64, u128 nonché usize;
• numeri con virgola che a seconda della precisione possono essere a 32 o 64 bit e assumono, rispettivamente, il nome di f32 e f64;
• i caratteri Unicode con il tipo char per la rappresentazione di lettere e simboli delle lingue e dei formati più disparati;
• i valori booleani con il tipo bool valorizzabili solo con true (valore logico vero) e false (valore logico falso).

I tipi composti invece sono essenzialmente due:

• array, sequenze posizionali di valori indicati con la notazione delle parentesi quadre ([...]);
• tuple, sequenze di valori non duplicati, rappresentate con la notazione delle parentesi tonde ((...)).

Dichiarazione di variabili con let

Per utilizzare una variabile in un programma è necessario dichiararla. Per farlo utilizziamo, la parola chiave let che può essere applicata con notazioni diverse tra cui distinguiamo:

• notazione "regolare" in cui specifichiamo il nome della variabile ed il tipo di dato separati dai due punti (:):
  

  let numero_figli: u8= 5;

• notazione "postfissa" in cui specifichiamo il tipo di dato applicandolo come suffisso al valore di inizializzazione. Questo esempio ha lo stesso significato di quello al punto precedente:
  

  // 5i8 significa valore 5 definito come intero senza segno a 8 bit
          let numero_figli = 5u8;

• applicazione di un tipo di dato di default in cui non andiamo a specificare esplicitamente il tipo di dato ma lasciamo che Rust scelga quello, a suo parere, più adatto:
  

  // questo, di default, sarà un i32
              let numero_figli = 5;
              // questo, di default, sarà un f64
              let prezzo   = 85.5;

Ricordiamo sempre che di default le variabili non sono modificabili. Impareremo a modificarle utilizzando la parola chiave mut.

Esempio: calcolo del costo totale

fn main() {
        // tipo di dato di default
        let prezzo_prodotto1 = 14.5;
        // notazione postfissa
        let prezzo_prodotto2 = 22f32;
        // notazione regolare
        let prezzo_prodotto3:f32 = 8.2;
        // variabile inizializzata con una somma
        let totale=prezzo_prodotto1+prezzo_prodotto2+prezzo_prodotto3;
        // stampa del risultato
        println!("Il costo totale dei tre prodotti è {} euro",totale);
    }

L'esempio dichiara tre variabili, ognuna indicante il prezzo di un prodotto, assegnando i relativi valori. Eseguendolo, otteniamo in risposta il messaggio Il costo totale dei tre prodotti è 44.7 euro.

La dichiarazione è stata fatta utilizzando le diverse modalità sopracitate e, sebbene non abbiamo ancora introdotto gli operatori di calcolo (lo faremo a breve) creiamo una quarta variabile, totale, inizializzandola con la somma dei tre, attuata impiegando l'operatore +. Alla fine provvediamo, alla stampa del risultato con la macro println!.

Per esercizio, si provi a cambiare i valori o a introdurne di differenti ma sempre tenendo presente un principio su cui torneremo: in una singola operazione, in questo linguaggio, possono essere inclusi solo variabili dello stesso tipo, non mescolando ad esempio numeri interi ed in virgola.