Passer au contenu principal
eLearner.app
Module 1 · Leçon 2 sur 22/14 dans le cours~10 min
Leçons du module (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

Exercice#rust.m1.l2.e1
Tentatives : 0Chargement…

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.

Chargement de l'éditeur…
Afficher l'indice

Crea la tupla con `let stats = (30, 95.5);`. Accedi al secondo elemento usando `stats.1` all'interno della macro `println!`.

Solution disponible après 3 tentatives

Exercice#rust.m1.l2.e2
Tentatives : 0Chargement…

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

Chargement de l'éditeur…
Afficher l'indice

Dichiara l'array con `let numbers = [1, 2, 3, 4, 5];` e accedi al terzo elemento indicizzandolo con `[2]`.

Solution disponible après 3 tentatives

Exercice#rust.m1.l2.e3
Tentatives : 0Chargement…

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

Chargement de l'éditeur…
Afficher l'indice

Usa la sintassi `let (x, y) = point;` per destrutturare la tupla e poi somma le variabili nel `println!`.

Solution disponible après 3 tentatives