Borrow & ownership

fn main() {
    let s = String::from("bonjour"); // s est propriétaire de la chaîne

    // s est utilisable ici
    println!("{s}");

} // s sort de portée → Rust appelle drop() → mémoire libérée automatiquement

fn main() {
    // Règle 1 : s1 est le seul propriétaire de "hello"
    let s1 = String::from("hello");

    // Règle 2 : si s2 prend la propriété, s1 n'est plus valide
    let s2 = s1; // move — s1 est invalidé

    // println!("{s1}"); // ERREUR : s1 a été déplacé

    println!("{s2}"); // OK

} // Règle 3 : s2 sort de portée → drop() appelé une seule fois

fn afficher(texte: String) {
    println!("{texte}");
} // texte est dropped ici

fn main() {
    let message = String::from("bonjour");

    afficher(message); // move : message passe dans afficher

    // println!("{message}"); // ERREUR : message a été moved
}

fn main() {
    let v1 = vec![1, 2, 3];
    let v2 = v1; // v1 est moved dans v2

    // v1 n'est plus utilisable
    // v2 est le seul propriétaire du vecteur

    for n in &v2 {
        println!("{n}");
    }
}

fn longueur(texte: &String) -> usize {
    texte.len()
} // texte est un emprunt — il n'est pas dropped ici

fn main() {
    let s = String::from("hello world");

    let n = longueur(&s); // on passe une référence, pas la valeur

    // s est toujours valide !
    println!("'{s}' contient {n} caractères");
}

fn main() {
    let r;
    {
        let x = 5;
        // r = &x; // ERREUR : x ne vivra pas assez longtemps
    }
    // println!("{r}"); // x est déjà détruit ici
}

fn ajouter_monde(texte: &mut String) {
    texte.push_str(", monde");
}

fn main() {
    let mut s = String::from("bonjour");

    ajouter_monde(&mut s);

    println!("{s}"); // bonjour, monde
}

fn main() {
    let mut v = vec![1, 2, 3];

    // Emprunt mutable
    let premier = &mut v[0];
    *premier = 100; // déréférencement pour modifier

    println!("{:?}", v); // [100, 2, 3]
}

fn main() {
    let mut s = String::from("hello");

    let r1 = &s;     // OK — première référence immuable
    let r2 = &s;     // OK — deuxième référence immuable
    // let r3 = &mut s; // ERREUR — &mut interdit tant que r1 et r2 existent

    println!("{r1} {r2}"); // r1 et r2 utilisées ici — leur scope se termine

    let r3 = &mut s; // OK maintenant — r1 et r2 ne sont plus actives
    r3.push_str(" world");

    println!("{r3}");
}

// ERREUR — cette fonction ne peut pas exister
fn creer_reference() -> &String {
    let s = String::from("hello");
    &s // s va être dropped à la fin de cette fonction !
}

// Solution : retourner la valeur elle-même
fn creer_string() -> String {
    String::from("hello")
}

fn premier_mot(texte: &str) -> &str {
    let octets = texte.as_bytes();

    for (i, &octet) in octets.iter().enumerate() {
        if octet == b' ' {
            return &texte[0..i]; // slice des i premiers caractères
        }
    }

    texte // toute la chaîne
}

fn main() {
    let phrase = String::from("bonjour monde");
    let mot = premier_mot(&phrase);

    // phrase.clear(); // ERREUR : phrase est empruntée par mot !

    println!("Premier mot : {mot}");
}

fn somme(nombres: &[i32]) -> i32 {
    nombres.iter().sum()
}

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let total = somme(&v);          // slice du Vec entier
    let partiel = somme(&v[1..4]);  // slice des éléments 1, 2, 3

    println!("Total : {total}");    // 15
    println!("Partiel : {partiel}"); // 9
}

let s = String::from("bonjour");

let debut = &s[0..3];  // "bon"
let fin   = &s[3..];   // "jour"
let tout  = &s[..];    // "bonjour" (équivalent à &s)

// Version cassée — corrigez-la
fn main() {
    let mut texte = String::from("hello");

    let r1 = &texte;
    texte.push_str(" world"); // ERREUR : texte emprunté par r1
    println!("{r1}");
}

// Version corrigée
fn main() {
    let mut texte = String::from("hello");

    {
        let r1 = &texte;
        println!("{r1}"); // r1 utilisée ici, scope terminé
    }

    texte.push_str(" world"); // OK : plus aucun emprunt actif
    println!("{texte}");
}

fn derniere_ligne(texte: &str) -> &str {
    texte.lines().last().unwrap_or("")
}

fn main() {
    let contenu = String::from("ligne 1\nligne 2\nligne 3");
    let derniere = derniere_ligne(&contenu);

    // contenu est toujours valide
    println!("Dernière ligne : {derniere}");
}