Lezioni del modulo (2/2)
Tipi primitivi
Rust è un linguaggio a tipizzazione statica, il che significa che deve conoscere il tipo di tutte le variabili al momento della compilazione. Di solito il compilatore può dedurre il tipo in base al valore assegnato, ma a volte è necessario o utile specificarlo manualmente.
I tipi primitivi in Rust si dividono in due grandi categorie: scalari (singolo valore) e composti (gruppo di valori).
Tipi Scalari
I tipi scalari rappresentano un singolo valore. Rust ne ha quattro fondamentali:
- Interi: Numeri senza virgola. Possono essere con segno (
i8,i16,i32,i64,i128,isize) o senza segno (u8,u16,u32,u64,u128,usize). Il tipo di default èi32. - Floating-point: Numeri con la virgola. Possono essere
f32of64(doppia precisione, default). - Booleani: Rappresentano la verità logica con
trueofalse(tipobool). - Caratteri: Un singolo punto di codice Unicode racchiuso tra apici singoli (tipo
char), es.'a','ℤ', o emoji'😻'.
Esempio di annotazione esplicita del tipo:
let x: i64 = 42;
let y: f64 = 3.1415;
let is_rust_awesome: bool = true;
let heart_emoji: char = '❤';
Tipi Composti
I tipi composti possono raggruppare più valori in un unico tipo. Rust ha due tipi composti primitivi principali:
Le Tuple
Una tupla raggruppa valori di tipi diversi in una collezione a dimensione fissa:
let person: (String, i32) = (String::from("Alice"), 30);
// Destrutturazione per estrarre valori
let (name, age) = person;
// Accesso diretto con l'indice usando il punto (.)
let name_direct = person.0;
let age_direct = person.1;
Gli Array (Vettori a dimensione fissa)
Un array raggruppa più elementi dello stesso tipo in una collezione a dimensione fissa memorizzata nello stack:
let numbers = [1, 2, 3, 4, 5]; // Rilevato come [i32; 5]
let first = numbers[0]; // Accesso per indice
let third = numbers[2];
Se provi ad accedere a un indice fuori dai limiti dell'array (es. numbers[10]), Rust interromperà immediatamente l'esecuzione (panico) a runtime invece di permettere accessi a memoria non autorizzata.
Confronto tra Tuple e Array
| Caratteristica | Tupla | Array |
|---|---|---|
| Tipo degli elementi | Possono essere diversi | Devono essere uguali |
| Dimensione | Fissa | Fissa |
| Accesso | Tramite punto (.0, .1) | Tramite indice ([0]) |
Prova tu
Dichiara una tupla chiamata stats contenente l'età 30 (intero) e il punteggio 95.5 (float). Successivamente stampa a schermo il punteggio accedendo direttamente al secondo elemento della tupla usando l'indice.
Mostra suggerimento
Crea la tupla con `let stats = (30, 95.5);`. Accedi al secondo elemento usando `stats.1` all'interno della macro `println!`.
Soluzione disponibile dopo 3 tentativi
Dichiara un array chiamato numbers contenente i valori interi da 1 a 5. Stampa a schermo il terzo elemento dell'array (indice 2) usando println!.
Mostra suggerimento
Dichiara l'array con `let numbers = [1, 2, 3, 4, 5];` e accedi al terzo elemento indicizzandolo con `[2]`.
Soluzione disponibile dopo 3 tentativi
Data la tupla `let point = (10, 20);`, usa la destrutturazione per estrarre i valori in due variabili chiamate `x` e `y`. Successivamente stampa la somma di `x` e `y`.
Mostra suggerimento
Usa la sintassi `let (x, y) = point;` per destrutturare la tupla e poi somma le variabili nel `println!`.
Soluzione disponibile dopo 3 tentativi