Antisèche Rust 🦀

⌨️ Entrées / sorties (I/O)📘 Module 4

Lire une ligne au clavier (stdin)

use std::io::{self, Write};

let mut ligne = String::new();
io::stdin().read_line(&mut ligne).unwrap();
let ligne = ligne.trim();        // enlève le \n final

Lire un nombre

let n: i32 = ligne.trim().parse().expect("pas un nombre");

Lire plusieurs valeurs sur une ligne

let nums: Vec<i32> = ligne.split_whitespace()
    .map(|x| x.parse().unwrap())
    .collect();

Écrire (sortie)

println!("avec saut de ligne");
print!("sans saut "); io::stdout().flush().unwrap(); // force l'affichage
eprintln!("erreur sur stderr");

⚙️ Bases & variables📘 Module 2

let x = 5;              // immuable
let mut y = 10;         // mutable
const MAX: u32 = 100;  // constante (MAJ)
let z: i64 = 42;       // type explicite
let x = x + 1;          // shadowing (re-déclare)

🔢 Types primitifs📘 Module 2

let t = (1, "a", 3.0); // tuple
let (a, b, c) = t;         // déstructuration
let arr = [0; 5];         // [0,0,0,0,0]

🔀 Flux de contrôle📘 Module 4

if n > 0 { … } else if n < 0 { … } else { … }
let s = if ok { 1 } else { 0 }; // if = expression

loop { break; }          // boucle infinie
while cond { … }
for i in 0..5 { … }      // 0..5 exclusif, 0..=5 inclus
for x in &vec { … }       // itère par référence

🛠️ Fonctions📘 Module 4

fn add(a: i32, b: i32) -> i32 {
    a + b          // PAS de ; = valeur de retour
}
fn log(msg: &str) { println!("{}", msg); }

🔑 Ownership & Borrowing📘 Modules 5-6

fn len(s: &String) -> usize { s.len() } // emprunte
fn push(s: &mut String) { s.push_str("!"); }

🔤 String & &str — méthodes📘 Module 9

let n: i32 = "42".parse().unwrap();
let s = format!("{}-{}", a, b); // construit une String

📚 Vec<T> — méthodes📘 Module 9

🗃️ HashMap<K,V>📘 Module 9

use std::collections::HashMap;
let mut m = HashMap::new();
m.insert("a", 1);
m.get("a");                 // Option<&V>
*m.entry("a").or_insert(0) += 1; // compteur
for (k, v) in &m { … }

❓ Option<T>📘 Module 8

Remplace null : Some(v) ou None.

if let Some(v) = opt { println!("{}", v); }
let n = opt.unwrap_or(0);

✅ Result<T,E> & erreurs📘 Module 10

Ok(v) ou Err(e). L'opérateur ? propage l'erreur.

fn lire() -> Result<String, io::Error> {
    let s = std::fs::read_to_string("f.txt")?; // propage si Err
    Ok(s)
}

🎯 Pattern matching📘 Module 8

match n {
    0 => "zéro",
    1 | 2 => "petit",
    3..=9 => "moyen",     // intervalle
    n if n < 0 => "négatif", // garde
    _ => "autre",          // obligatoire si non exhaustif
}

if let Some(x) = opt { … }   // un seul cas
while let Some(x) = it.next() { … }

🏗️ Structs & méthodes📘 Module 7

struct Point { x: f64, y: f64 }

impl Point {
    fn new(x: f64, y: f64) -> Self { Point{x, y} } // assoc.
    fn norme(&self) -> f64 { (self.x*self.x + self.y*self.y).sqrt() }
}
let p = Point::new(3.0, 4.0);
p.norme(); // 5.0

🔖 Enums📘 Module 8

enum Forme {
    Cercle(f64),            // porte des données
    Rect(f64, f64),
    Vide,
}
fn aire(f: &Forme) -> f64 {
    match f {
        Forme::Cercle(r) => 3.14 * r * r,
        Forme::Rect(w, h) => w * h,
        Forme::Vide => 0.0,
    }
}

🧩 Traits (interfaces)📘 Module 11

trait Decrire { fn desc(&self) -> String; }

impl Decrire for Point {
    fn desc(&self) -> String { format!("({},{})", self.x, self.y) }
}

fn afficher(x: &impl Decrire) { … } // trait en paramètre

🧬 Génériques & lifetimes📘 Module 12

fn max<T: PartialOrd>(a: T, b: T) -> T {
    if a > b { a } else { b }
}
// lifetime : la sortie vit aussi longtemps que les entrées
fn plus_long<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

🔁 Iterators (lazy)📘 Module 13

let somme: i32 = v.iter().filter(|&&x| x > 0).sum();
let carres: Vec<_> = (1..=5).map(|x| x*x).collect();

λ Closures📘 Module 13

let ajoute = |a, b| a + b;      // infère les types
let x = 10;
let incr = |n| n + x;           // capture x (environnement)
let conso = move || println!("{}", x); // move = prend possession

📦 Smart pointers📘 Module 14

🧵 Concurrence📘 Module 15

use std::thread;
let h = thread::spawn(|| { /* travail */ });
h.join().unwrap();          // attend la fin

use std::sync::mpsc;         // canal (channel)
let (tx, rx) = mpsc::channel();
thread::spawn(move || tx.send(42).unwrap());
rx.recv().unwrap();            // 42

🖨️ Affichage & format!📘 Module 2

println!("{:.2}", 3.14159);  // 3.14
println!("{x} = {x:b}");     // capture la variable x

📦 Cargo (CLI)📘 Module 1

🧪 Tests📘 Module 16

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn ca_marche() {
        assert_eq!(add(2, 2), 4);
        assert!(1 < 2);
    }
}

🗂️ Modules & visibilité📘 Module 16

mod math {
    pub fn carre(x: i32) -> i32 { x * x } // pub = public
}
use crate::math::carre;   // importe
carre(4);

⚠️ Pièges fréquents

• Le ; final transforme une valeur de retour en ().
• Move : réutiliser une String/Vec après let b=a; → erreur.
• & vs &mut : pas de mutable tant qu'un immuable vit.
• match non exhaustif : ajoute _.
• Oubli de mut : « cannot assign twice ».
• unwrap() sur None/Err → panique.
• Référence pendante : renvoyer & vers une variable locale.