Chapitre 06
Collections : Vec, tableaux, slices

1. Tableaux à taille fixe [T; N]

Un tableau Rust [T; N] est l'équivalent direct d'un tableau C T tab[N]; : sa taille N fait partie du type, elle est connue à la compilation, et le tableau vit entièrement sur la pile (aucune allocation dynamique). C'est le choix par défaut en contexte temps réel dès que la dimension est fixe — un état de robot à 3 degrés de liberté, un buffer de mesures IMU à taille constante, etc.

fn main() {
    // Un état [x, y, theta] : position + orientation d'un robot mobile.
    let etat: [f64; 3] = [0.0, 0.0, 0.0];

    // Initialisation répétée d'une valeur : [valeur; N]
    let zeros: [f64; 5] = [0.0; 5];

    println!("etat = {:?}", etat);
    println!("taille = {} éléments, {} octets",
        etat.len(), std::mem::size_of_val(&etat));

    // Accès par index : identique au C, mais vérifié à l'exécution.
    let x = etat[0];
    println!("x = {x}");
}

Comparaison avec C : en C, int tab[3]; ne connaît pas sa propre taille une fois passé à une fonction (il « decay » en pointeur) — il faut la transmettre à part. En Rust, le type [f64; 3] garde sa taille dans la signature de la fonction, et le compilateur vérifie tout à la compilation. Il n'y a ni allocation, ni pointeur caché : la disposition mémoire est identique à celle du tableau C, avec en plus les vérifications de bornes.

2. Vec<T> : le tableau dynamique

Vec<T> est l'équivalent de std::vector<T> en C++ : une structure de trois champs (pointeur vers le tas, longueur, capacité) qui gère elle-même son allocation. Utile quand la taille n'est pas connue à la compilation — une trajectoire chargée depuis un fichier, une liste d'obstacles détectés, etc.

fn main() {
    let mut mesures: Vec<f64> = Vec::new();

    mesures.push(1.2);
    mesures.push(3.4);
    mesures.push(-0.8);

    println!("len = {}, capacity = {}", mesures.len(), mesures.capacity());

    let dernier = mesures.pop(); // Option<f64> : Some(-0.8) ici
    println!("dernier retiré : {:?}", dernier);

    // Indexation comme un tableau classique.
    println!("mesures[0] = {}", mesures[0]);
}

Un Vec commence avec une capacité de 0. Chaque push qui dépasse la capacité actuelle déclenche une réallocation : le runtime alloue un nouveau bloc mémoire (typiquement le double de la taille précédente), copie tous les éléments existants, puis libère l'ancien bloc. C'est coûteux et surtout imprévisible en durée — problématique dans une boucle de contrôle temps réel. Si la taille finale est connue à l'avance, on la réserve d'un coup :

fn main() {
    // Réserve la capacité pour 100 éléments en une seule allocation.
    let mut trajectoire: Vec<f64> = Vec::with_capacity(100);

    for i in 0..100 {
        trajectoire.push(i as f64 * 0.01);
    }

    // Aucune réallocation n'a eu lieu pendant la boucle : capacity >= 100 dès le départ.
    println!("len = {}, capacity = {}", trajectoire.len(), trajectoire.capacity());
}

3. Slices &[T] et &mut [T]

Une slice est une vue empruntée sur une séquence contiguë d'éléments — un pointeur vers le début plus une longueur, sans posséder les données ni les copier. On peut obtenir une slice aussi bien à partir d'un tableau fixe que d'un Vec, ce qui en fait le type idéal pour écrire des fonctions génériques indépendantes du conteneur d'origine.

// Fonction générique : accepte un tableau fixe, un Vec, ou une autre slice.
fn norme(v: &[f64]) -> f64 {
    v.iter().map(|x| x * x).sum::<f64>().sqrt()
}

fn mettre_a_zero(v: &mut [f64]) {
    for x in v.iter_mut() {
        *x = 0.0;
    }
}

fn main() {
    let etat_fixe: [f64; 3] = [3.0, 4.0, 0.0];
    let mut etat_vec: Vec<f64> = vec![3.0, 4.0, 0.0];

    // &etat_fixe et &etat_vec[..] se convertissent tous deux en &[f64]
    println!("norme (tableau) = {}", norme(&etat_fixe));
    println!("norme (Vec)     = {}", norme(&etat_vec));

    mettre_a_zero(&mut etat_vec);
    println!("après remise à zéro : {:?}", etat_vec);

    // Sous-slice : les 2 premiers éléments seulement.
    let debut = &etat_fixe[0..2];
    println!("debut = {:?}", debut);
}

La règle de conception à retenir : quand une fonction n'a besoin que de lire ou modifier des éléments sans changer la taille de la collection, on la fait accepter une slice (&[T] ou &mut [T]) plutôt qu'un &Vec<T> ou un &[T; N] précis. C'est plus flexible pour l'appelant, sans coût : aucune copie n'a lieu, la slice est juste un pointeur + une longueur passés par valeur.

4. Accès sûr : indexation vs .get()

En C/C++, lire tab[i] avec un i hors bornes est un comportement indéfini : le programme peut lire n'importe quelle mémoire adjacente, silencieusement, et planter bien plus tard sans lien apparent avec la cause réelle. En Rust, l'indexation v[i] est vérifiée à l'exécution : si i dépasse la longueur, le programme panique immédiatement avec un message clair, plutôt que de corrompre la mémoire en silence.

fn main() {
    let mesures = vec![1.0, 2.0, 3.0];

    // Panic contrôlé si l'index est hors bornes (message explicite, pas de UB).
    // let x = mesures[10]; // décommenter -> "index out of bounds: the len is 3 but the index is 10"

    // Alternative sûre : .get() renvoie une Option, jamais de panic.
    match mesures.get(10) {
        Some(x) => println!("valeur = {x}"),
        None => println!("index hors bornes, valeur ignorée"),
    }

    // Idiomatique avec unwrap_or : valeur par défaut si absent.
    let x = mesures.get(1).copied().unwrap_or(0.0);
    println!("x = {x}");
}

5. Itérateurs de base

Rust encourage à parcourir les collections via des itérateurs plutôt que des boucles indexées manuelles — plus lisible, et le compilateur optimise généralement ce code aussi bien qu'une boucle C avec index. Un aperçu suffisant pour ce chapitre ; les itérateurs seront approfondis plus tard (adaptateurs paresseux, collect, performances).

fn main() {
    let vitesses: Vec<f64> = vec![0.5, 1.2, 0.8, 2.0];

    // Parcours simple par référence : ne consomme pas le Vec.
    for v in &vitesses {
        print!("{v} ");
    }
    println!();

    // .iter() explicite (équivalent à &vitesses dans un for), avec index via enumerate().
    for (i, v) in vitesses.iter().enumerate() {
        println!("vitesse[{i}] = {v}");
    }

    // .iter_mut() pour modifier en place.
    let mut copie = vitesses.clone();
    for v in copie.iter_mut() {
        *v *= 2.0;
    }
    println!("doublées = {:?}", copie);

    // .map() + .sum() : somme des carrés (utile pour une norme).
    let somme_carres: f64 = vitesses.iter().map(|v| v * v).sum();
    println!("somme des carrés = {somme_carres}");

    // .zip() : parcourir deux collections en parallèle, élément par élément.
    // Très utile pour les opérations vectorielles (addition, produit scalaire...).
    let a = vec![1.0, 2.0, 3.0];
    let b = vec![4.0, 5.0, 6.0];
    let produits: Vec<f64> = a.iter().zip(b.iter()).map(|(x, y)| x * y).collect();
    println!("produits terme à terme = {:?}", produits);
}

6. Fil rouge : vecteurs d'état, trajectoires, opérations vectorielles

Pour représenter l'état d'un robot, deux choix légitimes selon le contexte : [f64; N] quand N est fixe et connu (ex. un bras à 6 axes, toujours [f64; 6]), ou Vec<f64> quand la dimension varie selon la configuration chargée au démarrage. Une trajectoire — une suite de points Vec2 échantillonnés dans le temps — se représente naturellement en Vec<Vec2>, puisque son nombre de points n'est pas connu à la compilation.

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

/// Norme euclidienne d'un vecteur donné sous forme de slice.
/// Accepte aussi bien un [f64; N] qu'un Vec<f64>, grâce à &[f64].
fn norme(v: &[f64]) -> f64 {
    v.iter().map(|c| c * c).sum::<f64>().sqrt()
}

/// Produit scalaire de deux vecteurs de même longueur, via zip.
fn produit_scalaire(a: &[f64], b: &[f64]) -> f64 {
    a.iter().zip(b.iter()).map(|(x, y)| x * y).sum()
}

/// Addition élément par élément de deux vecteurs de même longueur.
fn addition(a: &[f64], b: &[f64]) -> Vec<f64> {
    a.iter().zip(b.iter()).map(|(x, y)| x + y).collect()
}

fn longueur_trajectoire(traj: &[Vec2]) -> f64 {
    let mut total = 0.0;
    for fenetre in traj.windows(2) {
        let dx = fenetre[1].x - fenetre[0].x;
        let dy = fenetre[1].y - fenetre[0].y;
        total += (dx * dx + dy * dy).sqrt();
    }
    total
}

fn main() {
    // État à dimension fixe : bras 6 axes, angles en radians.
    let etat_bras: [f64; 6] = [0.0, 0.3, -0.2, 0.0, 1.1, 0.0];
    println!("norme de l'état bras = {:.3}", norme(&etat_bras));

    // Deux vecteurs vitesse/accélération (dimension dynamique).
    let vitesse: Vec<f64> = vec![0.4, -0.1, 0.05];
    let acceleration: Vec<f64> = vec![0.02, 0.0, -0.01];

    println!("produit scalaire = {}", produit_scalaire(&vitesse, &acceleration));
    println!("somme            = {:?}", addition(&vitesse, &acceleration));

    // Trajectoire : suite de points 2D échantillonnés.
    let trajectoire: Vec<Vec2> = vec![
        Vec2 { x: 0.0, y: 0.0 },
        Vec2 { x: 1.0, y: 0.0 },
        Vec2 { x: 1.0, y: 1.0 },
    ];
    println!("longueur trajectoire = {:.3}", longueur_trajectoire(&trajectoire));
}

Exercices

fn moyenne(v: &[f64]) -> f64 {
    if v.is_empty() {
        return 0.0;
    }
    let somme: f64 = v.iter().sum();
    somme / v.len() as f64
}

fn main() {
    let mesures: Vec<f64> = vec![1.0, 2.0, 3.0, 4.0];
    println!("moyenne = {}", moyenne(&mesures));

    let vide: Vec<f64> = Vec::new();
    println!("moyenne (vide) = {}", moyenne(&vide));
}

fn produit_scalaire(a: &[f64], b: &[f64]) -> f64 {
    a.iter().zip(b.iter()).map(|(x, y)| x * y).sum()
}

fn main() {
    let a = [1.0, 2.0, 3.0];
    let b = [4.0, 5.0, 6.0];
    // 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32
    println!("produit scalaire = {}", produit_scalaire(&a, &b));
}

fn maximum(v: &[f64]) -> Option<f64> {
    if v.is_empty() {
        return None;
    }
    let mut max = v[0];
    for &x in v.iter() {
        if x > max {
            max = x;
        }
    }
    Some(max)
}

fn main() {
    let mesures = [3.0, 7.5, -2.0, 4.1];
    println!("max = {:?}", maximum(&mesures));

    let vide: [f64; 0] = [];
    println!("max (vide) = {:?}", maximum(&vide));
}

fn addition(a: &[f64], b: &[f64]) -> Vec<f64> {
    debug_assert_eq!(a.len(), b.len(), "les deux vecteurs doivent avoir la même longueur");

    let mut resultat = Vec::with_capacity(a.len());
    for (x, y) in a.iter().zip(b.iter()) {
        resultat.push(x + y);
    }
    resultat
}

fn main() {
    let vitesse = vec![0.4, -0.1, 0.05];
    let correction = vec![0.02, 0.0, -0.01];

    println!("somme = {:?}", addition(&vitesse, &correction));
}

Récapitulatif