---
title: Cours de programmation séquentielle
subtitle: Vecteurs
author: Orestis Malaspinas
sansfont: Sans Serif
---

# Liste de valeurs: `Vec<T>`{.rust}

## 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](https://doc.rust-lang.org/std/vec/struct.Vec.html)

# Fonctionalités d'un `Vec`

## Création

<pre><code data-trim="hljs rust" class="rust">
    fn main() {
    let v: Vec&lt;i32&gt; = 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
}    
</code></pre>

## Désallocation

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

<pre><code data-trim="hljs rust">
{
    let v = vec![1, 2, 3, 4];
    // on fait de trucs
} // v sort de la portée il est détruit
</code></pre>

## Ajouter/ôter des éléments

<pre><code data-trim="hljs rust" class="rust">
    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);
}
</code></pre>

# Lecture d'un `Vec`

## Lecture d'éléments (1/N)

<pre><code data-trim="hljs rust" class="rust">
    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);
}
</code></pre>

## Lecture d'éléments (2/N)

<pre><code data-trim="hljs rust" class="rust">
    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?
}
</code></pre>

## Lecture d'éléments (3/N)

<pre><code data-trim="hljs rust" class="rust">
    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);
}
</code></pre>

## Lecture d'éléments (4/N)

<pre><code data-trim="hljs rust" class="rust">
    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);
}
</code></pre>

## Itérer sur un `Vec` (1/2)

- Une façon d'itérer sur un vecteur est avec un `for`{.rust}.

<pre><code data-trim="hljs rust" class="rust">
    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);
}
</code></pre>


## Itérer sur un `Vec` (2/2)

<pre><code data-trim="hljs rust" class="rust">
    #[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);
}
</code></pre>
