Types primitifs

Rust est un langage à typage statique, ce qui signifie qu'il doit connaître le type de toutes les variables au moment de la compilation. Habituellement, le compilateur peut déduire le type en fonction de la valeur assignée, mais il est parfois nécessaire ou utile de le spécifier manuellement.

Les types primitifs en Rust se divisent en deux grandes catégories : scalaires (valeur unique) et composés (groupe de valeurs).

Types Scalaires

Les types scalaires représentent une valeur unique. Rust en possède quatre fondamentaux :

1. Entiers : Nombres sans virgule. Ils peuvent être signés (i8, i16, i32, i64, i128, isize) ou non signés (u8, u16, u32, u64, u128, usize). Le type par défaut est i32.
2. Nombres à virgule flottante : Nombres avec virgule. Ils peuvent être f32 ou f64 (double précision, par défaut).
3. Booléens : Représentent la vérité logique avec true ou false (type bool).
4. Caractères : Un seul point de code Unicode entouré de guillemets simples (type char), ex. 'a', 'ℤ', ou l'emoji '😻'.

Exemple d'annotation explicite du type :

let x: i64 = 42;
let y: f64 = 3.1415;
let is_rust_awesome: bool = true;
let heart_emoji: char = '❤';

Types Composés

Les types composés peuvent regrouper plusieurs valeurs en un seul type. Rust possède deux types composés primitifs principaux :

Les Tuples

Un tuple regroupe des valeurs de différents types dans une collection de taille fixe :

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;

Les Tableaux (Vecteurs à taille fixe)

Un tableau (array) regroupe plusieurs éléments du même type dans une collection à taille fixe stockée dans la pile (stack) :

let numbers = [1, 2, 3, 4, 5]; // Rilevato come [i32; 5]
let first = numbers[0]; // Accesso per indice
let third = numbers[2];

Si vous tentez d'accéder à un index en dehors des limites du tableau (ex. numbers[10]), Rust interrompra immédiatement l'exécution (panique) au moment de l'exécution au lieu de permettre des accès mémoire non autorisés.

Comparaison entre Tuples et Tableaux

À toi de jouer