ajout vec stuff

vec.md

+---
+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>