Généralités

• Liste dynamique de valeurs de même type: vecteurs.
• Nécessairement de même type.
• Garantie de contiguité en mémoire.
• La taille de la liste peut changer dynamiquement.
• Le type des éléments de Vec est générique.
• La documentation du type Vec se trouve ici

Création

    fn main() {
    let v: Vec<i32> = Vec::new(); // type annoté, pas moyen de le connaître
    println!("{:?} est de longueur {}", v, v.len()); // v.len() donne la longeur du vecteur

    let v = vec![1, 2, 3, 4]; // type inféré, création à l'aide d'un macro
    println!("{:?} est de longueur {}", v, v.len()); // v.len() donne la longeur du vecteur
}    

Désallocation

• Trivial: quand il sort de la portée le vecteur et tout ce qu’il contient est détruit.

{
    let v = vec![1, 2, 3, 4];
    // on fait de trucs
} // v sort de la portée il est détruit

Ajouter/ôter des éléments

    fn main() {
    let mut v = Vec::new();
    v.push(1); // type des éléments de v inféré
    v.push(2);
    v.push(3);
    assert_eq!(v, vec![1,2,3]);
    println!("{:?}", v);
    let last = v.pop(); // retoune une Some(i), ou None si vide
    println!("{:?} et le dernier {:?}", v, last);
}

Lecture d’éléments (1/N)

    fn main() {
    let v = vec![1, 2, 3, 4];
    
    let mut elem = v[1]; // que se passe-t-il à votre avis?
    println!("elem = {}", elem);
    elem += 1;
    println!("elem = {}, v = {:?}", elem, v);
    let mut elem = &v[1]; // que se passe-t-il à votre avis?
    println!("elem = {}", elem);
    *elem += 1;
    println!("elem = {}, v = {:?}", elem, v);
}

Lecture d’éléments (2/N)

    struct Int(i32);

fn main() {
    let v = vec![Int(1), Int(2), Int(3), Int(4)];
    
    let _elem = v[1]; // que se passe-t-il à votre avis?
    let _elem = &v[1]; // que se passe-t-il à votre avis?
}

Lecture d’éléments (3/N)

    fn main() {
    let v = vec![1, 2, 3, 4];
    
    let elem = &v[1]; // retourne une référence sur le premier élément
    println!("elem = {}", elem);
    let elem = v.get(1); // retourne une Option sur une référence sur le premier élément
    println!("elem = {:?}", elem);

    // let elem = &v[100]; // retourne une référence sur le 100e élément, hmmm.... panique
    // println!("elem = {}", elem);
    // let elem = v.get(100); // retourne une Option sur une référence sur le 100e élément
    // println!("elem = {:?}", elem);
}

Lecture d’éléments (4/N)

    fn main() {
    let mut v = vec![1, 2, 3, 4];
    v.push(-1);
    println!("v = {:?}", v);

    let elem = &v[1]; // retourne une Option sur une référence sur le premier élément
    println!("elem = {:?}", elem);

    v.push(10);
    // que vaut v ici?
    println!("v = {:?}", v);
}

Itérer sur un Vec (1/2)

• Une façon d’itérer sur un vecteur est avec un for.

    fn main() {
    let v = vec![1, 2, 3, 4];
    for i in &v {
        println!("i = {:?}", i);
    }

    let mut v = vec![1, 2, 3, 4];
    for i in &mut v {
        *i += 20;
    }
    println!("v = {:?}", v);
}

Itérer sur un Vec (2/2)

    #[derive(Debug)]
struct Int(i32);

fn main() {
    let v = vec![Int(1), Int(2), Int(3), Int(4)];
    for i in v {
        println!("i = {:?}", i);
    }
    println!("v = {:?}", v);

    let mut v = vec![1, 2, 3, 4];
    for i in &v {
        *i += 20;
    }
    println!("v = {:?}", v);
}