Vai al contenuto
eLearner.app
Modulo 1 · Lezione 2 di 22/14 nel corso~10 min
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:

  1. 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.
  2. Floating-point: Numeri con la virgola. Possono essere f32 o f64 (doppia precisione, default).
  3. Booleani: Rappresentano la verità logica con true o false (tipo bool).
  4. Caratteri: Un singolo punto di codice Unicode racchiuso tra apici singoli (tipo char), es. 'a', 'ℤ', o emoji '😻'.

Esempio di annotazione esplicita del tipo:

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

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

Code
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

CaratteristicaTuplaArray
Tipo degli elementiPossono essere diversiDevono essere uguali
DimensioneFissaFissa
AccessoTramite punto (.0, .1)Tramite indice ([0])

Prova tu

Esercizio#rust.m1.l2.e1
Tentativi: 0Caricamento…

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.

Caricamento editor…
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

Esercizio#rust.m1.l2.e2
Tentativi: 0Caricamento…

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!.

Caricamento editor…
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

Esercizio#rust.m1.l2.e3
Tentativi: 0Caricamento…

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`.

Caricamento editor…
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