Benvenuto alla seconda lezione del corso su Rust! Dopo aver configurato l’ambiente e scritto il tuo primo programma, è il momento di approfondire alcuni dei concetti fondamentali: variabili, costanti e tipi di dati primitivi. Questi sono i mattoni su cui costruirai tutto il tuo codice Rust. Pronti? Iniziamo! 

Variabili e Costanti in Rust

In Rust, le variabili vengono dichiarate con la parola chiave let. Per impostazione predefinita, le variabili in Rust sono immutabili. Questo significa che non possono essere modificate dopo la loro inizializzazione, a meno che non utilizzi la parola chiave mut.

Esempio: Variabili Immutabili

fn main() {
    let nome = "Saverio"; // Variabile immutabile
    println!("Il nome è: {}", nome);
    // nome = "Mario"; // Questo genera un errore!
}

Esempio: Variabili Mutabili

Se vuoi che una variabile sia modificabile, usa mut:

fn main() {
    let mut contatore = 0; // Variabile mutabile
    println!("Contatore iniziale: {}", contatore);
    contatore += 1;
    println!("Contatore aggiornato: {}", contatore);
}

Costanti

Le costanti in Rust vengono dichiarate con la parola chiave const. A differenza delle variabili, le costanti:

  1. Devono avere un tipo esplicito.
  2. Sono sempre immutabili.
  3. Devono essere definite con valori conosciuti a tempo di compilazione.

Esempio: Costanti

const PI: f64 = 3.141592653589793;
fn main() {
    println!("Il valore di PI è: {}", PI);
}

Tipi Primitivi in Rust

Rust offre diversi tipi primitivi che possono essere suddivisi in queste categorie:

  1. Numeri interi (i8, i16, i32, i64, i128, u8, u16, u32, u64, u128).
  2. Numeri a virgola mobile (f32, f64).
  3. Booleani (bool).
  4. Stringhe (String, &str).

Esempi di Tipi Primitivi

fn main() {
    let numero_intero: i32 = 42;
    let numero_virgola: f64 = 3.14;
    let valore_logico: bool = true;
    let saluto: &str = "Ciao, Rust!";

    println!("Intero: {}", numero_intero);
    println!("Float: {}", numero_virgola);
    println!("Booleano: {}", valore_logico);
    println!("Stringa: {}", saluto);
}

Operazioni di Base

Rust supporta tutte le operazioni matematiche di base: somma (+), sottrazione (-), moltiplicazione (*), divisione (/), modulo (%).

Esempio: Operazioni Matematiche

fn main() {
    let x = 10;
    let y = 3;

    println!("Somma: {}", x + y);
    println!("Sottrazione: {}", x - y);
    println!("Moltiplicazione: {}", x * y);
    println!("Divisione: {}", x / y);
    println!("Modulo: {}", x % y);
}

Conversioni tra Tipi

Rust richiede conversioni esplicite tra tipi, usando metodi come .parse() o .to_string().

Esempio: Da Stringa a Numero

fn main() {
    let numero: i32 = "42".parse().unwrap();
    println!("Numero convertito: {}", numero);
}

Esempio: Da Numero a Stringa

fn main() {
    let numero = 42;
    let stringa = numero.to_string();
    println!("Stringa convertita: {}", stringa);
}

Esercizi Pratici

  1. Esercizio 1: Crea una variabile mutabile che rappresenta il punteggio di un giocatore e aggiorna il valore man mano che il giocatore guadagna punti.
  2. Esercizio 2: Dichiara una costante per il valore di gravità (9.81) e stampala sullo schermo.
  3. Esercizio 3: Converti una stringa di input in un numero e calcola il doppio di quel valore.

Conclusione

In questa lezione, hai imparato i concetti fondamentali di variabili, costanti e tipi primitivi in Rust. Questi concetti ti aiuteranno a creare programmi sempre più complessi. Nella prossima lezione, esploreremo come usare le strutture di controllo come if, else, e match per gestire il flusso del tuo programma.