Structures & contrôle

Les conditions permettent d'exécuter du code selon qu'une expression est vraie ou fausse. En Rust, la condition doit toujours être un booléen (bool).

En Rust, if est une expression : il retourne une valeur.

// if retourne une valeur
fn main() {
    let condition = true;
    let nombre = if condition { 5 } else { 6 };
    println!("nombre = {}", nombre); // 5

    // Exemple pratique
    let age = 20;
    let statut = if age >= 18 { "Majeur" } else { "Mineur" };
    println!("Statut : {}", statut);
}

// Les types des deux branches doivent correspondre !
let x = if condition {
    5 // Type : i32
} else {
    // "six" // ERREUR : types incompatibles
    6 // OK : même type
};

if comme expression : les deux branches (if et else) doivent retourner le même type. Si une branche n'a pas de valeur de retour, elle retourne () (le type unit).

Rust propose trois types de boucles : loop (infinie), while (avec condition), et for (itération).

loop crée une boucle infinie. On doit utiliser break pour en sortir.

// Boucle infinie simple
fn main() {
    let mut compteur = 0;
    loop {
        compteur += 1;
        println!("Compteur : {}", compteur);
        if compteur == 5 {
            break; // Sort de la boucle
        }
    }
}

// loop peut retourner une valeur !
fn main() {
    let mut compteur = 0;
    let resultat = loop {
        compteur += 1;
        if compteur == 10 {
            break compteur * 2; // Retourne 20
        }
    };
    println!("Résultat : {}", resultat); // 20
}

while exécute une boucle tant qu'une condition est vraie.

fn main() {
    let mut nombre = 3;

    // Compte à rebours
    while nombre != 0 {
        println!("{}!", nombre);
        nombre -= 1;
    }
    println!("Décollage !");
}

// Exemple pratique : saisie utilisateur
use std::io;

fn main() {
    let mut input = String::new();
    let mut essais = 3;
    while essais > 0 {
        println!("Entrez le mot de passe ({} essais restants) :", essais);
        input.clear();
        io::stdin().read_line(&mut input).expect("Erreur de lecture");
        if input.trim() == "secret" {
            println!("Accès autorisé !");
            break;
        }
        essais -= 1;
    }
}

for permet d'itérer sur une collection ou une plage de valeurs. C'est la boucle la plus utilisée en Rust.

// Itérer sur une plage
fn main() {
    for i in 1..6 {
        println!("i = {}", i); // 1, 2, 3, 4, 5
    }
    // Plage inclusive (avec =)
    for i in 1..=5 {
        println!("i = {}", i); // 1, 2, 3, 4, 5
    }
}

// Itérer sur un tableau
fn main() {
    let nombres = [10, 20, 30, 40, 50];
    for nombre in nombres {
        println!("Nombre : {}", nombre);
    }
    // Avec index
    for (index, valeur) in nombres.iter().enumerate() {
        println!("Index {} : {}", index, valeur);
    }
}

// Itérer sur un vecteur
fn main() {
    let fruits = vec!["pomme", "banane", "orange"];
    for fruit in &fruits {
        println!("Fruit : {}", fruit);
    }
    // fruits est toujours utilisable ici (on a itéré par référence)
    println!("Nombre de fruits : {}", fruits.len());
}

for vs while : préfère toujours for quand tu itères sur une collection — plus sûr (pas de risque d'index hors limite) et plus idiomatique en Rust.

break sort de la boucle, continue passe à l'itération suivante.

// break : sortir de la boucle
fn main() {
    for i in 1..10 {
        if i == 5 {
            break; // Sort complètement de la boucle
        }
        println!("{}", i); // Affiche 1, 2, 3, 4
    }
}

// continue : passer à l'itération suivante
fn main() {
    for i in 1..10 {
        if i % 2 == 0 {
            continue; // Saute les nombres pairs
        }
        println!("{}", i); // Affiche 1, 3, 5, 7, 9
    }
}

// Exemple pratique : trouver un élément
fn main() {
    let nombres = vec![1, 5, 8, 12, 15, 20];
    let recherche = 12;
    let mut trouve = false;
    for nombre in nombres {
        if nombre == recherche {
            println!("Trouvé : {}", nombre);
            trouve = true;
            break; // Pas besoin de continuer
        }
    }
    if !trouve {
        println!("Non trouvé");
    }
}

Les labels permettent de contrôler des boucles imbriquées.

// Boucles imbriquées avec labels
fn main() {
    let mut compteur = 0;
    'exterieur: loop {
        println!("Compteur extérieur = {}", compteur);
        let mut restant = 10;
        loop {
            println!("  Restant = {}", restant);
            if restant == 7 {
                break; // Sort de la boucle intérieure
            }
            if compteur == 2 {
                break 'exterieur; // Sort des DEUX boucles
            }
            restant -= 1;
        }
        compteur += 1;
    }
}

Labels : ils commencent par ' (apostrophe) et permettent de break/continue une boucle spécifique au milieu de boucles imbriquées.

match est l'outil le plus puissant de Rust pour le contrôle de flux. Il vérifie tous les cas possibles et le compilateur garantit qu'aucun n'est oublié.

Les guards ajoutent une condition supplémentaire après un pattern.

fn main() {
    let nombre = 4;
    match nombre {
        n if n < 0 => println!("Négatif : {}", n),
        n if n % 2 == 0 => println!("Pair : {}", n),
        n => println!("Impair positif : {}", n),
    }
}

// Exemple avec Option
fn main() {
    let nombre: Option<i32> = Some(7);
    match nombre {
        Some(n) if n < 5 => println!("Petit : {}", n),
        Some(n) if n >= 5 && n < 10 => println!("Moyen : {}", n),
        Some(n) => println!("Grand : {}", n),
        None => println!("Pas de valeur"),
    }
}

if let et while let sont des raccourcis pour match quand on ne s'intéresse qu'à un seul cas.

Écrire une fonction qui classe un âge en catégorie :

• 0-12 : Enfant
• 13-17 : Adolescent
• 18-64 : Adulte
• 65+ : Senior

// Solution :
fn classifier_age(age: u32) -> &'static str {
    match age {
        0..=12 => "Enfant",
        13..=17 => "Adolescent",
        18..=64 => "Adulte",
        _ => "Senior",
    }
}

Calculer la somme des nombres de 1 à n.

// Solution :
fn somme_jusqua(n: i32) -> i32 {
    let mut somme = 0;
    for i in 1..=n {
        somme += i;
    }
    somme
}

fn main() {
    println!("Somme 1 à 10 : {}", somme_jusqua(10)); // 55
}

Vérifier si un nombre est premier.

// Solution :
fn est_premier(n: u32) -> bool {
    if n < 2 {
        return false;
    }
    for i in 2..n {
        if n % i == 0 {
            return false;
        }
    }
    true
}

fn main() {
    for n in 2..=20 {
        if est_premier(n) {
            println!("{} est premier", n);
        }
    }
}

Ce cours couvre le contrôle de flux. Voir structures-enums.md pour les structures, les enums, Option/Result en détail, et le pattern matching avancé sur des données structurées.