Chapitre 02
Variables, types & mutabilité

1. let : immutable par défaut

Première surprise pour qui vient du C/C++ : en Rust, une variable déclarée avec let est immuable par défaut. C'est l'inverse de l'habitude C/C++, où il faut ajouter const explicitement pour interdire la réaffectation.

fn main() {
    let vitesse_max = 2.5; // m/s — immuable
    println!("Vitesse max : {vitesse_max}");

    // vitesse_max = 3.0; // ERREUR de compilation : cannot assign twice
    //                    // to immutable variable `vitesse_max`
}

Pour autoriser la réaffectation, il faut le déclarer explicitement avec mut :

fn main() {
    let mut vitesse = 0.0_f64; // m/s
    println!("Vitesse initiale : {vitesse}");

    vitesse += 0.5; // accélération, autorisé grâce à `mut`
    println!("Vitesse après accélération : {vitesse}");
}

2. const et static

let (même immuable) est une liaison locale, évaluée à l'exécution. Pour des valeurs vraiment constantes, connues à la compilation, Rust propose const et static :

// `const` : inlinée partout où elle est utilisée, pas d'adresse mémoire fixe.
// Le type est TOUJOURS obligatoire.
const PERIODE_BOUCLE_MS: u32 = 10; // boucle de contrôle à 100 Hz

// `static` : une seule instance en mémoire, à une adresse fixe, durée de vie 'static.
static NOM_ROBOT: &str = "R2-Atelier";

fn main() {
    println!("{NOM_ROBOT} tourne à {PERIODE_BOUCLE_MS} ms par cycle");
}

3. Le shadowing

Le shadowing consiste à redéclarer une nouvelle variable avec le même nom via let. Ce n'est pas de la mutation : chaque let x = ... crée une variable distincte qui masque la précédente. On peut même changer de type au passage.

fn main() {
    let angle = "45"; // &str, lu depuis une config par exemple
    let angle: f64 = angle.parse().expect("angle invalide");
    let angle = angle.to_radians(); // même nom, nouvelle variable, type inchangé ici

    println!("Angle en radians : {angle}");
}

4. Types scalaires

Rust a un système de types statique et explicite. Les scalaires de base :

• Entiers signés : i8, i16, i32, i64, i128, isize
• Entiers non signés : u8, u16, u32, u64, u128, usize
• Flottants : f32, f64
• Booléen : bool (true / false, jamais 0/1 implicite)
• Caractère : char, un scalaire Unicode sur 4 octets (pas juste ASCII comme le char C)

isize et usize ont la taille d'un pointeur sur la plateforme cible (souvent 64 bits) — l'équivalent de ssize_t/size_t en C. On les utilise surtout pour indexer des collections, pas pour du calcul physique.

fn main() {
    let compteur_cycles: u64 = 0;
    let erreur_position: i32 = -3; // en pas moteur, peut être négatif
    let asservissement_actif: bool = true;
    let unite: char = 'm'; // mètres

    println!("{compteur_cycles} {erreur_position} {asservissement_actif} {unite}");
}

5. f32 vs f64 pour le calcul robotique

Rust infère f64 par défaut pour un littéral flottant sans annotation — contrairement au C où un littéral comme 1.0 est un double aussi, mais où l'on bascule souvent vers float pour la performance sans trop y penser. En Rust, ce choix doit être délibéré :

6. Inférence et annotations explicites

Rust infère le type dans la grande majorité des cas, mais accepte (et recommande parfois) une annotation explicite pour la lisibilité ou quand l'inférence est ambiguë :

fn main() {
    let pas = 0.01; // inféré : f64
    let angle_cible: f64 = 1.57; // annotation explicite, utile pour la doc du code
    let nb_articulations = 6u8; // suffixe de type directement sur le littéral

    println!("{pas} {angle_cible} {nb_articulations}");
}

7. Débordement d'entiers

En C, un débordement d'entier signé est un comportement indéfini, et un débordement d'entier non signé « boucle » silencieusement (wrapping). Rust est plus strict et plus prévisible :

• En profil debug, un débordement déclenche un panic! à l'exécution — l'erreur est détectée immédiatement.
• En profil release (optimisé), par défaut, le débordement fait un wrapping silencieux (comportement identique au C pour les non signés), pour ne pas payer le coût de la vérification en production.

fn main() {
    let compteur_pas: u8 = 250;
    // let depassement = compteur_pas + 10; // panic en debug ! (u8 max = 255)

    // Méthodes explicites et sûres, indépendantes du profil de compilation :
    let a = compteur_pas.wrapping_add(10);   // boucle silencieusement : 4
    let b = compteur_pas.checked_add(10);    // None si débordement, Some(x) sinon
    let c = compteur_pas.saturating_add(10); // bloque à la valeur max : 255

    println!("wrapping={a} checked={b:?} saturating={c}");
}

8. Conversions avec as

Rust n'effectue aucune conversion implicite entre types numériques, même entre i32 et i64, ou f32 et f64. Il faut convertir explicitement avec as (ou des méthodes comme TryFrom pour des conversions pouvant échouer).

fn main() {
    let pas_moteur: i32 = 4096;
    let pas_moteur_f: f64 = pas_moteur as f64; // conversion explicite, sans perte ici

    let angle_rad: f64 = 3.14159265358979;
    let angle_f32: f32 = angle_rad as f32; // perte de précision assumée et visible

    let grand: i64 = 1_000_000_000_000;
    let tronque: i32 = grand as i32; // troncature silencieuse : le résultat n'est PAS 1e12 !

    println!("{pas_moteur_f} {angle_f32} {tronque}");
}

9. Tuples et déstructuration

Un tuple regroupe plusieurs valeurs de types potentiellement différents, sans avoir besoin de définir une structure nommée. Pratique pour retourner plusieurs valeurs d'une fonction, ou pour une donnée légère et locale comme une pose 2D.

fn main() {
    // Une pose robot 2D : position (x, y) en mètres, orientation theta en radians
    let pose: (f64, f64, f64) = (1.20, 0.35, 0.78);

    // Accès par index
    println!("x = {}", pose.0);

    // Déstructuration : la manière idiomatique de lire un tuple
    let (x, y, theta) = pose;
    println!("x={x} y={y} theta={theta}");
}

10. Fil rouge : angles en radians

Dans ce cours, tous les calculs d'angle internes se font en radians, en f64, conformément à la convention de la plupart des bibliothèques scientifiques (et des fonctions trigonométriques de std). On ne convertit en degrés qu'à l'affichage ou à la saisie utilisateur.

use std::f64::consts::PI;

fn deg_vers_rad(deg: f64) -> f64 {
    deg * PI / 180.0
}

fn rad_vers_deg(rad: f64) -> f64 {
    rad * 180.0 / PI
}

fn main() {
    let angle_articulation_deg = 90.0;
    let angle_rad = deg_vers_rad(angle_articulation_deg);

    println!("{angle_articulation_deg}° = {angle_rad} rad");
    println!("retour : {} °", rad_vers_deg(angle_rad));
}

Exercices

fn main() {
    let angle_deg: f64 = 135.0;
    let angle_rad = angle_deg.to_radians();

    println!("{angle_deg:.4}° = {angle_rad:.4} rad");
}

fn main() {
    let valeur = "3.14";                       // &str
    let valeur: f64 = valeur.parse().unwrap();  // f64
    let valeur = valeur.round();                // toujours f64, mais arrondi : 3.0

    println!("{valeur}");
}

fn main() {
    let valeur: u8 = u8::MAX; // 255

    let a = valeur.checked_add(1);   // None : 256 ne rentre pas dans un u8
    let b = valeur.wrapping_add(1);  // 0 : rebouclage silencieux (255 + 1 mod 256)
    let c = valeur.saturating_add(1); // 255 : plafonné à la valeur max du type

    println!("checked={a:?} wrapping={b} saturating={c}");
}

fn main() {
    let pose: (f64, f64, f64) = (2.0, -0.5, 45.0); // x (m), y (m), theta (deg)
    let (x, y, theta) = pose;
    let theta = theta.to_radians(); // shadowing : theta devient l'angle en radians

    println!("Robot en ({x}, {y}) avec un cap de {theta:.4} rad");
}

Récapitulatif