Rust

Rappel des concepts essentiels de Rust : syntaxe, types, ownership et bonnes pratiques.

🚀 Projet Cargo

• cargo new mon_projet → Créer un nouveau projet
• cargo build → Compiler le projet
• cargo run → Compiler et exécuter
• cargo check → Vérifier sans compiler
• cargo build --release → Build optimisé pour production

📦 Variables & Mutabilité

• let x = 5; → Variable immutable (par défaut)
• let mut x = 5; → Variable mutable
• const MAX: i32 = 100; → Constante (toujours typée)

Note : En Rust, les variables sont immutables par défaut. Utilise mut pour les modifier.

🔢 Types de données

Entiers

• i8, i16, i32, i64, i128 → Entiers signés
• u8, u16, u32, u64, u128 → Entiers non signés (positifs)
• let age: i32 = 25;
• let count: u32 = 100;

Flottants

• f32 → Flottant 32 bits
• f64 → Flottant 64 bits (défaut)
• let price: f64 = 19.99;

Booléens & Caractères

• let is_active: bool = true;
• let lettre: char = 'A';

Chaînes de caractères

• let s: &str = "hello"; → String slice (référence, immutable)
• let s: String = String::from("hello"); → String (modifiable, heap)

🖨️ Affichage avec println!

• println!("Hello"); → Affiche du texte
• println!("x = {}", x); → Affiche une variable
• println!("{} + {} = {}", a, b, sum); → Plusieurs valeurs
• println!("{:?}", vecteur); → Debug print (pour tableaux/vecteurs)

Note : Le ! indique que c'est une macro, pas une fonction.

🔀 Conditions

• if condition { ... }
• if ... else { ... }
• if ... else if ... else { ... }

If comme expression :

• let status = if age >= 18 { "adulte" } else { "mineur" };

🔁 Boucles

Boucle for

• for i in 0..5 { } → De 0 à 4 (5 exclus)
• for i in 0..=5 { } → De 0 à 5 (5 inclus)
• for elem in &vecteur { } → Itérer sur un vecteur

Boucle while

• while condition { ... }

Boucle infinie

• loop { ... break; } → Boucle infinie avec break pour sortir

⚙️ Fonctions

• fn ma_fonction() { } → Sans paramètres ni retour
• fn add(a: i32, b: i32) -> i32 { a + b } → Avec retour implicite
• fn carre(x: i32) -> i32 { return x * x; } → Retour explicite
• fn afficher(nom: &str, age: i32) { } → Plusieurs paramètres

Note : Sans ; à la fin, la dernière expression est le retour implicite.

📋 Tableaux (Array)

Taille fixe, définie à la compilation.

• let arr: [i32; 5] = [1, 2, 3, 4, 5];
• arr[0] → Accès au premier élément
• arr.len() → Longueur du tableau

📊 Vecteurs (Vec)

Taille dynamique, comme une liste.

• let mut v = vec![10, 20, 30]; → Créer un vecteur
• v.push(40); → Ajouter un élément
• v[1] → Accéder à l'index 1
• v.len() → Nombre d'éléments
• for n in &v { } → Itérer sur le vecteur

🔐 Ownership (Propriété)

Concept clé de Rust pour la gestion mémoire sans garbage collector.

Règles

• Chaque valeur a un propriétaire unique
• Quand le propriétaire sort du scope, la valeur est libérée

Move (Déplacement)

• let s1 = String::from("hello");
• let s2 = s1; → s1 est déplacé vers s2, s1 n'est plus valide

Clone (Copie explicite)

• let s2 = s1.clone(); → Copie profonde, s1 reste valide

Copy (Types simples)

• Les types simples (i32, f64, bool, char) sont copiés automatiquement
• let a = 5; let b = a; → a et b sont valides

📎 Borrowing (Emprunt)

Permet d'utiliser une valeur sans en prendre la propriété.

• &variable → Référence immutable (lecture seule)
• &mut variable → Référence mutable (lecture/écriture)

Règles :

• Plusieurs références immutables OK
• Une seule référence mutable à la fois
• Pas de référence mutable si références immutables existent

📝 Cargo.toml

Fichier de configuration du projet.

• [package] → Infos du projet (name, version, edition)
• [dependencies] → Dépendances externes