Collections done

cpp_basics_for_STL.typ

@@ -86,8 +86,140 @@ Je vous recommande de lire cette page pour plus d'exemples :
 
 #new-section-slide("Vecteurs")
 
+#slide(
+  title: "Qu'es-ce qu'un vecteur",
+)[
+Un *std::vector* est une collection de la STL. Il s'agit d'un tableau de taille
+dynamique.
+
+La mémoire est gérée par l'objet. Il n'y a donc pas besoin de l'allouer avec
+`malloc` ou de la libérer avec `free`.
+
+Il est possible, par exemple, de l'allouer comme un tableau ou de lui donner un
+taille fixe et une valeur de remplissage
+
+```cpp
+std::vector<int> v = {1, 2, 3, 4};
+size_t n = 100;
+std::vector<float> v1(n, 0.0);
+```
+]
+
+#slide(
+  title: "Autres méthodes intéressantes d'un vecteur",
+)[
+Il est possible de récupérer un pointeur sur les données du vecteur en utilisant
+la méthode `data` :
+
+```cpp
+std::vector<int> v = {1, 2, 3, 4};
+int* ptr = v.data();
+```
+
+Grâce aux méthodes `begin` et `end`, on peut également itérer sur le vecteur
+avec une range-for loop :
+
+```cpp
+std::vector<int> v = {1, 2, 3, 4};
+for (int &i : v){
+  i = 2*i;
+}
+```
+
+Il est possible de redimensionner le vecteur à l'aide de la méthode `resize`
+]
+
 #new-section-slide("Tableaux et Spans")
 
+#slide(
+  title: "Le type tableau (C-style array)",
+)[
+En C++, il existe un type tableau. On peut par exemple déclarer un tableau
+statique de cette manière :
+
+```cpp
+int a[3] = {1, 2, 3}; // Déclaration statique
+```
+
+On peut aussi déclarer un tableau dynamique sur le tas de cette manière :
+
+```cpp
+int *a = new int[100]; // Allocation dynamique
+
+delete[] a; // Libération de la mémoire
+```
+
+On accède aux éléments d'un tableau avec l'opérateur `[]`, par exemple : ```cpp
+a[5] = 12.3;
+```
+]
+
+#slide(
+  title: "Les incovénients du type tableau",
+)[
+  Le type tableau est un héritage du C. Comme c'est le cas en C, si le tableau est
+  casté en pointeur, on perd l'information sur la taille du tableau.
+
+  Si le tableau est alloué dynamiquement, il faut gérer la mémoire.
+
+  Le type tableau ne propose aucune propriété, ni méthode. Il s'agit uniquement
+  d'une zone mémoire.
+]
+
+#slide(
+  title: "Le type std::array",
+)[
+La STL propose une collection pour les tableaux statiques, `std::array`. Cette
+collection combine les perfomances d'un simple tableau, et les avantages d'une
+collection STL.
+
+On peut l'initialiser de cette manière : ```cpp
+std::array<int, 3> a2 = {1, 2, 3};
+```
+
+Comme c'est un tableau statique, il n'est pas nécessaire de libérer la mémoire.
+
+Le type `std::array` offre, entre autres, les méthodes `data`, `begin` ou `end`.
+
+La méthode `size` permet de connaître la taille du tableau.
+
+La méthode `at` permet d'accèder à un élément du tableau en vérifiant que
+l'index passé est valide (bounds-check).
+]
+
+#slide(
+  title: "Les spans",
+)[
+Il peut arriver que nous ayons uniquement un tableau simple ou un pointeur vers
+des données. En résumé, une simple zone mémoire.
+
+Si nous voulons pouvoir utiliser notre zone mémoire comme une collection STL,
+pour profiter des différentes méthodes que nous avons vu, par exemple. Il existe
+les `std::span`.
+
+Cette structure encapsule simplement un pointeur et la taille de la zone
+pointée.
+]
+
+#slide(title: "Exemple de span")[
+```cpp
+int *ptr = new int[5];
+std::span<int> sp{ptr, 5};
+
+int i = 0;
+for(int &val: sp){
+  val = i++;
+}
+
+auto mid = sp.subspan(1, 3);
+for(int &val: mid){
+  val *= -1;
+}
+
+delete[] ptr;
+```
+]
+
 #new-section-slide("Closures")
 
 #new-section-slide("Algorithmes STL")