updated base_2

base_2.md

@@ -67,6 +67,82 @@
     }
     ```
 
+# Les fonctions (4/N)
+
+## Arguments de fonctions
+
+- Les arguments d'une fonction sont toujours passés **par copie**.
+- Les arguments d'une fonction ne peuvent **jamais** être modifiés.
+
+    ```C
+    void set_to_two(int a) { // a est une nouvelle variable
+        // la valeur de a une copie de celle passée en argument
+        // lorsque la fonction est appelée, ici -1
+
+        a = 2; // la valeur de a est fixée à 2
+    } // a est détruite
+
+    int main() {
+        int x = -1;
+        set_to_two(x); // -1 est passé en argument
+        // x vaudra toujours -1 ici
+    }
+    ```
+
+# Les fonctions (5/N)
+
+## Arguments de fonctions: pointeurs
+
+- Pour modifier un variable, il faut passer son **adresse mémoire**.
+- L'adresse d'une variable, `x`{.C}, est accédé par `&x`{.C}.
+- Un **pointeur** vers une variable entière a le type, `int *x`{.C}.
+- La sytaxe `*x`{.C} sert à **déréférencer** le pointeur.
+
+    ```C
+    void set_to_two(int *a) { 
+        // a contient une copie de l'adresse de la
+        // variable passée en argument
+
+        *a = 2; // on accède à la valeur pointée par a,
+                // et on lui assigne 2
+    } // le pointeur est détruit, pas la valeur pointée
+    int main() {
+        int x = -1;
+        set_to_two(&x); // l'adresse de x est passée
+        // x vaudra 2 ici
+    }
+    ```
+
+<!-- TODO quiz;
+```C
+void set_to_two(int *a) { 
+    a = 2;
+}
+int main() {
+    int x = -1;
+    set_to_two(&x);
+}
+
+
+void add_two(int *a) { 
+    *a += 2;
+}
+
+int main() {
+    int x = -1;
+    add_two(&x);
+}
+
+void add_two(int a) { 
+    a += 2;
+    printf("%d", a);
+}
+int main() {
+    int x = -1;
+    add_two(&x);
+}
+``` -->
+
 # La fonction `main()` (1/N)
 
 ## Généralités
@@ -101,3 +177,104 @@ $ echo $?
 $ if [ $? -eq 0 ]; then echo "OK" ; else echo "ERROR"; fi
 ERROR # si tout s'est mal passé
 ```
+
+# Les tableaux (1/N)
+
+## Généralités
+
+- C offre uniquement des tableaux statiques
+    - Un tableau est un "bloc" de mémoire contigüe associé à un nom
+        - taille fixe déterminée à la déclaration du tableau
+        - la taille ne peut pas être changée.
+    - Pas d’assignation de tableaux.
+    - Un tableau déclaré dans une fonction ou un bloc est détruit à la sortie de celle/celui-ci
+        - $\Rightarrow$ Un tableau local à une fonction ne doit **jamais être retourné** (aussi valable pour toute variable locale)!
+- Les éléments d’un tableau sont accédés avec `[i]`{.C} où `i`{.C} est l’index de l’élément.
+- Le premier élément du tableau à l’index `0`{.C}!
+- Lorsqu’un tableau est déclaré, la taille de celui-ci doit toujours être spécifiée, sauf s’il est initialisé lors de sa déclaration.
+
+# Les tableaux (2/N)
+
+## Exemple
+
+```C
+float tab1[5]; // tableau de floats à 5 éléments
+               // ses valeurs sont indéfinies
+
+int tab2[] = {1, 2, 3}; // tableau de 3 entiers
+
+int val = tab2[1]; // val vaut 2 à présent
+
+int w = tab1[5]; // index hors des limites du tableau
+                 // comportement indéfini!
+                 // pas d'erreur du compilateur
+```
+
+<!-- TODO QUIZ:
+
+```C
+int a1[5]; // OK
+int a2[] = { 1, 2, 3 }; // OK
+int a3[4][5]; // OK
+int [] a4;  // Erreur
+int a5[];   // Erreur
+
+int[] function(void) {  // Erreur
+	int array[5];   // OK
+	return array;   // Erreur
+}
+
+void foo(int a[]) {  // OK
+	a[3] = 0;  // OK
+}
+
+void bar(void) {
+	int a[5]; // OK
+	foo(a);   // OK
+	a = a5;   // Erreur
+}
+``` -->
+
+<!-- ```C
+#include <stdio.h>
+
+int main(void) {
+	char i;
+	char a1[] = { 100,200,300,400,500 };
+	char a2[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+	a2[10] = 42;
+
+	for (i = 0; i < 5; i++) {
+		printf("a1[%d] = %d\n", i, a1[i]);
+	}
+
+	return 0;
+}
+``` -->
+
+
+# Les tableaux (3/N)
+
+## Les tableaux comme argument
+
+- Un tableau n'est rien d'autre que le pointeur vers sa première case.
+- Pas moyen de connaître sa taille: `sizeof()`{.C} inutile.
+- Quand on passe un tableau en argument à une fonction: toujours spécifier sa taille.
+
+    ```C
+    void foo(int tab[]) { // sans taille...
+        for (int i = 0; i < ?; ++i) { // on sait pas
+            printf("tab[%d] = %d\n", i, tab[i]);
+        }
+    }
+    // avec taille, [n] pas obligatoire
+    void bar(int tab[n], int n) {
+        for (int i = 0; i < n; ++i) {
+            printf("tab[%d] = %d\n", i, tab[i]);
+        }
+    }
+    ```
+
+<!-- TODO quiz:  -->
+
+<!-- que retourne sizeof(tab[]) -->