Variables & fonctions

En Rust, les variables sont déclarées avec le mot-clé let. Une des particularités de Rust est que les variables sont immutables par défaut.

Par défaut, les variables Rust sont immutables : impossible de changer leur valeur après leur déclaration.

let x = 5;
println!("x = {}", x);

x = 6;  // ERREUR DE COMPILATION !
// error[E0384]: cannot assign twice to immutable variable `x`

Pourquoi ? L'immutabilité par défaut aide à éviter les bugs. Pour modifier une variable, il faut le déclarer explicitement avec mut.

Pour rendre une variable modifiable, on ajoute mut après let.

let mut x = 5;
println!("x = {}", x);  // Affiche : x = 5
x = 6;                   // OK !
println!("x = {}", x);  // Affiche : x = 6

// Modification multiple
let mut compteur = 0;
compteur = compteur + 1;
compteur = compteur + 1;
println!("compteur = {}", compteur);  // Affiche : compteur = 2

Conseil : utiliser mut seulement quand nécessaire — rend le code plus sûr et plus facile à comprendre.

Les constantes sont déclarées avec const et sont toujours immutables. Elles doivent avoir un type explicite et sont évaluées à la compilation.

// Constante (MAJUSCULES par convention)
const MAX_POINTS: u32 = 100_000;
const PI: f64 = 3.14159;

fn main() {
    println!("Le maximum est : {}", MAX_POINTS);
    // Impossible avec une constante :
    // const ne peut pas être mut
    // const doit avoir un type explicite
}

Différences entre let et const :

Le shadowing permet de redéclarer une variable avec le même nom — différent de la mutabilité.

let x = 5;
println!("x = {}", x);  // 5

let x = x + 1;  // Nouvelle variable qui masque la précédente
println!("x = {}", x);  // 6

let x = x * 2;  // Encore une nouvelle variable
println!("x = {}", x);  // 12

// Le shadowing permet de changer le type !
let espaces = "   ";           // Type : &str
let espaces = espaces.len();   // Type : usize
println!("Il y a {} espaces", espaces);  // 3

Shadowing vs mut :

• mut : modifie la valeur, même type obligatoire.
• let (shadowing) : crée une nouvelle variable, peut changer de type.

Rust est un langage statiquement typé : chaque variable a un type connu à la compilation. Rust peut souvent inférer le type, mais on peut aussi l'annoter explicitement.

Les types scalaires représentent une valeur unique. Rust en a quatre types principaux :

// 1. ENTIERS (integers)
let a: i32 = 42;        // Entier signé 32 bits
let b: u64 = 100;       // Entier non signé 64 bits
let c = 5;              // i32 par défaut

// Différentes tailles : i8, i16, i32, i64, i128, isize
//                       u8, u16, u32, u64, u128, usize

// 2. FLOTTANTS (floating-point)
let x: f64 = 2.5;       // 64 bits (défaut)
let y: f32 = 3.14;      // 32 bits

// 3. BOOLÉENS (boolean)
let vrai: bool = true;
let faux: bool = false;

// 4. CARACTÈRES (char)
let lettre: char = 'A';
let emoji: char = '🦀';  // Unicode !

Types d'entiers en Rust :

Les types composés regroupent plusieurs valeurs dans un seul type.

// 1. TUPLES - Types différents, taille fixe
let personne: (&str, i32, bool) = ("Alice", 25, true);

// Accès par déstructuration
let (nom, age, actif) = personne;
println!("{} a {} ans", nom, age);

// Accès par index
println!("Nom : {}", personne.0);
println!("Age : {}", personne.1);

// 2. TABLEAUX - Même type, taille fixe
let nombres: [i32; 5] = [1, 2, 3, 4, 5];

// Accès par index
let premier = nombres[0];  // 1
let dernier = nombres[4];  // 5

// Tableau avec valeur répétée
let zeros = [0; 10];  // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

// 3. SLICES - Vue sur une partie d'un tableau
let slice = &nombres[1..3];  // [2, 3]

Les fonctions sont omniprésentes en Rust. Elles sont déclarées avec fn et utilisent la convention snake_case pour les noms.

Les paramètres doivent toujours avoir un type explicite.

// Un paramètre
fn afficher_nombre(x: i32) {
    println!("Le nombre est : {}", x);
}

// Plusieurs paramètres
fn additionner(a: i32, b: i32) {
    let somme = a + b;
    println!("{} + {} = {}", a, b, somme);
}

// Appel
fn main() {
    afficher_nombre(42);
    additionner(5, 7);
}

// Paramètres de types différents
fn presenter(nom: &str, age: i32, actif: bool) {
    println!("{} a {} ans, actif : {}", nom, age, actif);
}

Une fonction retourne une valeur avec -> suivi du type. La dernière expression est retournée automatiquement (pas de return nécessaire).

// Fonction avec retour
fn additionner(a: i32, b: i32) -> i32 {
    a + b  // PAS de point-virgule !
}

fn main() {
    let resultat = additionner(5, 3);
    println!("5 + 3 = {}", resultat);  // 8
}

// Avec return explicite (utile pour retour anticipé)
fn valeur_absolue(x: i32) -> i32 {
    if x < 0 {
        return -x;  // Retour anticipé
    }
    x  // Retour normal
}

// Plusieurs retours possibles
fn diviser(a: i32, b: i32) -> Option<i32> {
    if b == 0 {
        return None;  // Division par zéro
    }
    Some(a / b)
}

Attention ! En Rust, une expression sans point-virgule est retournée. Avec point-virgule, c'est une instruction qui ne retourne rien.

Pour éviter de copier les données, on peut passer des références aux fonctions.

// Sans référence (copie la valeur)
fn afficher_nombre(x: i32) {
    println!("Nombre : {}", x);
}

// Avec référence (emprunte la valeur)
fn afficher_chaine(s: &String) {
    println!("Chaîne : {}", s);
}

// Référence mutable (peut modifier)
fn incrementer(x: &mut i32) {
    *x += 1;  // * = déréférencement
}

fn main() {
    let nombre = 42;
    afficher_nombre(nombre);  // Copie

    let texte = String::from("Hello");
    afficher_chaine(&texte);  // Emprunte

    let mut compteur = 0;
    incrementer(&mut compteur);
    println!("Compteur : {}", compteur);  // 1
}

L'ownership est le concept le plus important et unique de Rust. C'est ce qui permet à Rust d'être sûr sans ramasse-miettes (garbage collector).

Règles de base :

1. Chaque valeur a un propriétaire unique.
2. Il ne peut y avoir qu'un seul propriétaire à la fois.
3. Quand le propriétaire sort du scope, la valeur est libérée.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // s1 est "déplacé" vers s2
    // println!("{}", s1);  // ERREUR ! s1 n'est plus valide
    println!("{}", s2);     // OK
}

// Exemple avec fonction
fn prend_ownership(s: String) {
    println!("{}", s);
}  // s est libéré ici

fn main() {
    let texte = String::from("hello");
    prend_ownership(texte);
    // println!("{}", texte);  // ERREUR ! texte a été déplacé dans la fonction
}

Types Copy : les types simples (i32, f64, bool, char) sont Copy — ils sont copiés au lieu d'être déplacés.

Les références permettent d'emprunter une valeur sans en prendre l'ownership.

fn calculer_longueur(s: &String) -> usize {
    s.len()
}  // s sort du scope, mais ne possède pas la String

fn main() {
    let texte = String::from("hello");
    let longueur = calculer_longueur(&texte);
    println!("'{}' a {} caractères", texte, longueur); // texte est toujours valide !
}

// Multiples références immutables OK
fn main() {
    let s = String::from("hello");
    let r1 = &s;
    let r2 = &s;
    println!("{} et {}", r1, r2);  // OK
}

Compléter ce code pour qu'il compile :

fn main() {
    let x = 5;
    // Ajoute le code nécessaire pour que x devienne 10
    println!("x = {}", x);  // Doit afficher "x = 10"
}

// Solution :
fn main() {
    let mut x = 5;  // Ajouter mut
    x = 10;
    println!("x = {}", x);
}

Créer une fonction qui multiplie deux nombres :

// À compléter
fn multiplier(/* paramètres */) /* -> type */ {
    // ton code
}

fn main() {
    let resultat = multiplier(6, 7);
    println!("6 x 7 = {}", resultat);  // Doit afficher 42
}

// Solution :
fn multiplier(a: i32, b: i32) -> i32 {
    a * b
}

Créer une fonction qui double un nombre sans le déplacer :

fn doubler(/* référence mutable */) {
    // ton code
}

fn main() {
    let mut nombre = 5;
    doubler(/* passer référence */);
    println!("Nombre : {}", nombre);  // Doit afficher 10
}

// Solution :
fn doubler(x: &mut i32) {
    *x *= 2;
}

fn main() {
    let mut nombre = 5;
    doubler(&mut nombre);
    println!("Nombre : {}", nombre);
}

Ce cours couvre les bases de Rust — variables, types, fonctions, ownership et borrowing.

Prochaines étapes :

• Pratiquer avec de petits programmes.
• Apprendre les structures (struct) et les enums — voir structures-enums.md.
• Maîtriser le pattern matching — voir structures-et-controle.md.
• Explorer les collections (Vec, HashMap) — voir collections.md.

Ressources recommandées :

• The Rust Book (en français) : https://jimskapt.github.io/rust-book-fr/
• Rustlings (exercices) : https://github.com/rust-lang/rustlings
• Rust by Example : https://doc.rust-lang.org/rust-by-example/
• Forum Rust : https://users.rust-lang.org/