Rust : Maîtriser la Ownership et les Lifetimes

Rust Ownership : Le cœur du langage

L'ownership est le concept fondamental qui rend Rust unique. Comprendre ce système est essentiel pour écrire du code Rust efficace et sûr.

1. Les règles de l'Ownership

fn main() {
    // Règle 1: Chaque valeur a un propriétaire unique
    let s1 = String::from("Hello");
    
    // Règle 2: Transfert de propriété (move)
    let s2 = s1; // s1 n'est plus valide
    // println!("{}", s1); // Erreur de compilation!
    println!("{}", s2); // OK
    
    // Règle 3: La valeur est libérée quand le propriétaire sort du scope
    {
        let temp = String::from("temporary");
        // temp est détruit à la fin du bloc
    }
    
    // Clonage explicite pour copier
    let s3 = s2.clone();
    println!("{} and {}", s2, s3); // OK, on a deux copies
    
    // Types Copy (entiers, bools, chars)
    let x = 5;
    let y = x; // Copy, pas move
    println!("{} and {}", x, y); // OK pour les types Copy
}

2. Borrowing et Références

fn main() {
    let mut s = String::from("Hello");
    
    // Emprunt immutable
    let len = calculate_length(&s);
    println!("Length of '{}' is {}", s, len);
    
    // Emprunt mutable
    change(&mut s);
    println!("Changed: {}", s);
    
    // Règles de borrowing
    let r1 = &s; // OK
    let r2 = &s; // OK - plusieurs références immutables
    println!("{} and {}", r1, r2);
    
    // Après utilisation des références immutables
    let r3 = &mut s; // OK maintenant
    r3.push_str(" World");
    println!("{}", r3);
}

fn calculate_length(s: &String) -> usize {
    s.len() // s est une référence, pas le propriétaire
}

fn change(s: &mut String) {
    s.push_str(", Rust!");
}

Conclusion

La maîtrise de l'ownership en Rust ouvre la voie à une programmation système sûre et performante.