Chapitre 05
Structs, enums & méthodes

1. Structs : regrouper des données liées

En C, on regroupe des données liées dans un struct. Rust reprend exactement cette idée, mais y ajoute des méthodes, des garanties de mutabilité et un système de dérivation automatique (#[derive(...)]) qui évite beaucoup de code répétitif.

1.1 Struct nommée

struct Vec2 {
    x: f64,
    y: f64,
}

fn main() {
    let v = Vec2 { x: 1.0, y: 2.0 };
    println!("v.x = {}, v.y = {}", v.x, v.y);
}

On instancie une struct avec la syntaxe NomDeStruct { champ: valeur, ... }. L'ordre des champs n'a pas d'importance, seuls les noms comptent — contrairement à un struct C initialisé positionnellement ({1.0, 2.0}).

1.2 Tuple structs

Une tuple struct a un nom mais des champs anonymes, accessibles par index (.0, .1, ...). Pratique pour donner un type distinct à une donnée simple, sans avoir besoin de nommer ses champs.

struct Angle(f64);        // radians, mais avec un type dédié
struct Couleur(u8, u8, u8);

fn main() {
    let a = Angle(1.5708);
    let rouge = Couleur(255, 0, 0);
    println!("angle = {} rad, canal rouge = {}", a.0, rouge.0);
}

1.3 Unit structs

Une unit struct n'a aucun champ. Elle sert de marqueur de type, souvent pour implémenter un trait sans avoir besoin de stocker de donnée (on approfondira ça au chapitre 7 sur les traits).

struct CapteurSimule;

fn main() {
    let _c = CapteurSimule;
}

1.4 Mutabilité : tout ou rien

En Rust, la mutabilité se déclare sur la variable, pas sur le champ individuellement. Si v n'est pas mut, aucun de ses champs n'est modifiable — même partiellement.

let mut v = Vec2 { x: 0.0, y: 0.0 };
v.x = 3.0;   // OK : v est mut
v.y += 1.0;  // OK

let w = Vec2 { x: 0.0, y: 0.0 };
// w.x = 3.0;  // ERREUR de compilation : w n'est pas mut

2. Blocs impl : méthodes et fonctions associées

Contrairement au C où les fonctions qui manipulent un struct flottent séparément (souvent préfixées vec2_norme(...)), Rust permet d'attacher directement des fonctions au type via un bloc impl. C'est similaire aux méthodes d'une classe C++, sans héritage d'implémentation.

struct Vec2 {
    x: f64,
    y: f64,
}

impl Vec2 {
    // Fonction associée : pas de "self", sert de constructeur.
    // Convention : Self::new(...)
    fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }

    // Méthode en lecture seule : emprunte &self, ne consomme rien.
    fn norme(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }

    // Méthode qui modifie l'instance : emprunte &mut self.
    fn normalise(&mut self) {
        let n = self.norme();
        self.x /= n;
        self.y /= n;
    }

    // Méthode qui consomme self : transforme la valeur et la rend.
    fn vers_tuple(self) -> (f64, f64) {
        (self.x, self.y)
    }
}

fn main() {
    let mut v = Vec2::new(3.0, 4.0);
    println!("norme = {}", v.norme());   // 5.0
    v.normalise();
    println!("normalise = ({}, {})", v.x, v.y);

    let t = v.vers_tuple();  // v est déplacée ici, plus utilisable après
    println!("{:?}", t);
}

Trois formes de self possibles dans une méthode, exactement comme les emprunts vus au chapitre 4 :

• &self — emprunt immuable : la méthode lit l'instance sans la modifier (le cas le plus courant).
• &mut self — emprunt mutable : la méthode modifie l'instance en place.
• self — prise de possession : la méthode consomme l'instance (souvent pour une conversion finale).

3. Enums : bien plus qu'en C

En C, un enum n'est qu'une liste d'entiers nommés, et une union permet de superposer plusieurs représentations en mémoire sans qu'aucune information ne dise laquelle est active (le programmeur doit s'en souvenir lui-même, source classique de bugs). Rust fusionne les deux idées dans un seul concept sûr : chaque variante d'un enum peut porter ses propres données, et le compilateur sait toujours quelle variante est active.

3.1 Variantes simples

#[derive(Debug, PartialEq)]
enum Etat {
    Arrete,
    EnMouvement,
    Erreur,
}

fn main() {
    let e = Etat::EnMouvement;
    if e == Etat::EnMouvement {
        println!("Le robot bouge.");
    }
}

3.2 Variantes avec données

Chaque variante peut embarquer des champs différents — impossible à exprimer nativement avec un enum C. C'est l'équivalent sûr d'une union taguée.

#[derive(Debug)]
enum Articulation {
    Rotoide(f64),     // angle en radians
    Prismatique(f64), // déplacement en mètres
}

fn main() {
    let j1 = Articulation::Rotoide(0.785);
    let j2 = Articulation::Prismatique(0.12);
    println!("{:?} {:?}", j1, j2);
}

3.3 match sur un enum

match force à traiter toutes les variantes (exhaustivité vérifiée à la compilation). Impossible d'oublier un cas comme on oublierait un case dans un switch C — le compilateur refuse de compiler sinon.

fn decrire(j: &Articulation) -> String {
    match j {
        Articulation::Rotoide(angle) => format!("rotoïde, angle = {:.3} rad", angle),
        Articulation::Prismatique(dist) => format!("prismatique, déplacement = {:.3} m", dist),
    }
}

fn main() {
    let j = Articulation::Rotoide(1.2);
    println!("{}", decrire(&j));
}

3.4 Aperçu : Option<T> et Result<T, E>

Deux enums de la bibliothèque standard, omniprésents en Rust, ne sont rien d'autre que des enums avec des variantes génériques :

enum Option<T> {
    Some(T),
    None,
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Option<T> remplace l'usage d'un pointeur nul (pas de NULL en Rust) et Result<T, E> remplace les codes d'erreur ad hoc (errno, valeurs sentinelles -1). On y reviendra en détail au chapitre 8 ; pour l'instant, retiens simplement que ce sont des enums que l'on traite avec match comme n'importe quel autre.

4. Derive : générer du code automatiquement

L'attribut #[derive(...)] demande au compilateur de générer automatiquement l'implémentation de certains traits standards, en analysant les champs de la struct ou de l'enum. C'est l'équivalent Rust d'écrire soi-même un opérateur de comparaison ou une fonction de copie en C++, mais sans risque d'oubli ou d'incohérence.

#[derive(Debug, Clone, Copy, PartialEq)]
struct Vec2 {
    x: f64,
    y: f64,
}

fn main() {
    let a = Vec2 { x: 1.0, y: 2.0 };
    let b = a;              // Copy : b est une copie, a reste utilisable
    println!("{:?}", a);    // Debug : affichage avec {:?}
    println!("{}", a == b); // PartialEq : comparaison structurelle
}

• Debug — permet d'afficher la valeur avec {:?} (utile en println! pour déboguer).
• Clone — ajoute une méthode .clone() qui duplique explicitement la valeur.
• Copy — rend le type copiable implicitement (bit à bit), comme les types numériques de base ; possible seulement si tous les champs sont eux-mêmes Copy.
• PartialEq — permet de comparer avec == et !=, champ par champ.

5. Fil rouge : géométrie et état du robot

On construit maintenant les briques de base qui serviront tout au long du cours : un vecteur 2D, un vecteur 3D, l'état d'un robot mobile, et le type d'une articulation.

#[derive(Debug, Clone, Copy, PartialEq)]
struct Vec2 {
    x: f64,
    y: f64,
}

impl Vec2 {
    fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }

    fn norme(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }

    fn produit_scalaire(&self, autre: &Vec2) -> f64 {
        self.x * autre.x + self.y * autre.y
    }

    fn plus(&self, autre: &Vec2) -> Vec2 {
        Vec2::new(self.x + autre.x, self.y + autre.y)
    }
}

#[derive(Debug, Clone, Copy, PartialEq)]
struct Vec3 {
    x: f64,
    y: f64,
    z: f64,
}

impl Vec3 {
    fn new(x: f64, y: f64, z: f64) -> Self {
        Self { x, y, z }
    }

    fn norme(&self) -> f64 {
        (self.x * self.x + self.y * self.y + self.z * self.z).sqrt()
    }

    fn produit_scalaire(&self, autre: &Vec3) -> f64 {
        self.x * autre.x + self.y * autre.y + self.z * autre.z
    }

    fn plus(&self, autre: &Vec3) -> Vec3 {
        Vec3::new(self.x + autre.x, self.y + autre.y, self.z + autre.z)
    }
}

/// État d'un robot mobile 2D : position (x, y) et cap theta (radians).
#[derive(Debug, Clone, Copy, PartialEq)]
struct EtatRobot {
    x: f64,
    y: f64,
    theta: f64,
}

impl EtatRobot {
    fn new(x: f64, y: f64, theta: f64) -> Self {
        Self { x, y, theta }
    }

    /// Avance le robot de `d` mètres dans la direction de son cap actuel
    /// (modèle cinématique très simplifié, sans dérive latérale).
    fn avance(&mut self, d: f64) {
        self.x += d * self.theta.cos();
        self.y += d * self.theta.sin();
    }
}

/// Type d'articulation d'un bras robotique.
#[derive(Debug, Clone, Copy)]
enum Articulation {
    Rotoide(f64),     // angle en radians
    Prismatique(f64), // déplacement en mètres
}

fn main() {
    let a = Vec2::new(1.0, 0.0);
    let b = Vec2::new(0.0, 1.0);
    println!("a . b = {}", a.produit_scalaire(&b));  // 0.0 (orthogonaux)
    println!("norme de a + b = {}", a.plus(&b).norme());

    let mut robot = EtatRobot::new(0.0, 0.0, 0.0);
    robot.avance(2.0);
    println!("{:?}", robot);  // EtatRobot { x: 2.0, y: 0.0, theta: 0.0 }

    let joints = [Articulation::Rotoide(0.5), Articulation::Prismatique(0.1)];
    for j in &joints {
        println!("{:?}", j);
    }
}

Exercices

struct Vec2 {
    x: f64,
    y: f64,
}

impl Vec2 {
    fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }

    fn norme(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }

    fn produit_scalaire(&self, autre: &Vec2) -> f64 {
        self.x * autre.x + self.y * autre.y
    }
}

fn main() {
    let a = Vec2::new(1.0, 0.0);
    let b = Vec2::new(0.0, 1.0);
    println!("norme de a = {}", a.norme());               // 1.0
    println!("a . b = {}", a.produit_scalaire(&b));      // 0.0
}

impl Vec2 {
    // ... new, norme, produit_scalaire déjà définis ...

    fn moins(&self, autre: &Vec2) -> Vec2 {
        Vec2::new(self.x - autre.x, self.y - autre.y)
    }

    fn distance(&self, autre: &Vec2) -> f64 {
        self.moins(autre).norme()
    }
}

fn main() {
    let a = Vec2::new(0.0, 0.0);
    let b = Vec2::new(3.0, 4.0);
    println!("distance = {}", a.distance(&b));  // 5.0
}

#[derive(Debug)]
enum TypeCapteur {
    Lidar(f64),
    Camera { largeur: u32, hauteur: u32 },
    Imu,
}

fn decrire(c: &TypeCapteur) -> String {
    match c {
        TypeCapteur::Lidar(portee) => format!("Lidar, portée max {:.1} m", portee),
        TypeCapteur::Camera { largeur, hauteur } => {
            format!("Caméra {}x{}", largeur, hauteur)
        }
        TypeCapteur::Imu => "IMU (accéléromètre + gyroscope)".to_string(),
    }
}

fn main() {
    let capteurs = [
        TypeCapteur::Lidar(12.0),
        TypeCapteur::Camera { largeur: 1920, hauteur: 1080 },
        TypeCapteur::Imu,
    ];
    for c in &capteurs {
        println!("{}", decrire(c));
    }
}

#[derive(Debug, Clone, Copy, PartialEq)]
struct EtatRobot {
    x: f64,
    y: f64,
    theta: f64,
}

impl EtatRobot {
    fn new(x: f64, y: f64, theta: f64) -> Self {
        Self { x, y, theta }
    }

    fn avance(&mut self, d: f64) {
        self.x += d * self.theta.cos();
        self.y += d * self.theta.sin();
    }

    fn tourne(&mut self, dtheta: f64) {
        self.theta += dtheta;
    }

    fn avance_et_tourne(&mut self, d: f64, dtheta: f64) {
        self.avance(d);
        self.tourne(dtheta);
    }
}

fn main() {
    let mut robot = EtatRobot::new(0.0, 0.0, 0.0);
    robot.avance_et_tourne(1.0, std::f64::consts::FRAC_PI_2); // avance de 1m, puis tourne de 90°
    println!("{:?}", robot);
}

Récapitulatif