deplacements

base_1.md

@@ -364,135 +364,9 @@ else
     x = -1; // toujours évalué
 ```
 
-<!-- # Structures de contrôle: `switch`{.C} .. `case`{.C} (1/2)
+# Quiz: `if ... else`{.C}
 
-```C
-switch (expression) {
-    case constant-expression:
-        instructions;
-        break; // optionnel
-    case constant-expression:
-        instructions;
-        break; // optionnel
-    // ...
-    default:
-        instructions;
-}
-```
-
-**Que se passe-t-il si `break`{C} est absent?**
-
-# Structures de contrôle: `switch`{.C} .. `case`{.C} (2/2)
-
-```C
-int x = 0;
-switch (x) {
-    case 0:
-    case 1:
-        printf("0 ou 1\n");
-        break;
-    case 2:
-        printf("2\n");
-        break;
-    default:
-        printf("autre\n");
-}
-``` -->
-
-**Dangereux, mais c'est un moyen d'avoir un "ou" logique dans un case.**
-
-# Quiz: `if ... else, switch ... case`{.C}
-
-## [Quiz: `if ... else, switch ... case`{.C}](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033916)
-
-# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (1/4)
-
-## La boucle `for`{.C}
-
-```C
-for (expression1; expression2; expression3) {
-    instructions;
-}
-```
-
-## La boucle `while`{.C}
-
-```C
-while (expression) {
-    instructions;
-}
-```
-
-## La boucle `do ... while`{.C}
-
-```C
-do {
-    instructions;
-} while (expression);
-```
-
-# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (2/4)
-
-## La boucle `for`{.C}
-
-```C
-int sum = 0; // syntaxe C99
-for (int i = 0; i < 10; i++) {
-    sum += i;
-}
-
-for (int i = 0; i != 1; i = rand() % 4) { // ésotérique
-    printf("C'est plus ésotérique.\n");
-}
-```
-
-# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (3/4)
-
-## La boucle `while`{.C}
-
-```C
-int sum = 0, i = 0;
-while (i < 10) { // pas assuré·e·s de faire un tour
-    sum += i;
-    i += 1;
-}
-```
-
-## La boucle `do ... while`{.C}
-
-```C
-int sum = 0, i = 0;
-do { // assuré·e·s de faire un tour
-    sum += i;
-    i += 1;
-} while (i < 10);
-```
-
-# Structures de contrôle: `continue`{.C}, `break`{.C} (4/4)
-
-- `continue`{.C} saute à la prochaine itération d'une boucle.
-
-    ```C
-    int i = 0;
-    while (i < 10) {
-        if (i == 3) {
-            continue;
-        }
-        printf("%d\n", i);
-        i += 1;
-    }
-    ```
-
-- `break`{.C} quitte le bloc itératif courant d'une boucle.
-
-    ```C
-    for (int i = 0; i < 10; i++) {
-        if (i == 3) {
-            break;
-        }
-        printf("%d\n", i);
-    }
-    ```
+## [Quiz: `if ... else`{.C}](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033916)
 
 # Les variables (1/2)
 

base_2.md

 % Base II
 % Inspirés des slides de F. Glück
-% 25 septembre 2019
+% 23 septembre 2020
 
-# Représentation des variables en mémoire (1/N)
-
-## La mémoire
-
-* La mémoire est:
-    - ... un ensemble de bits,
-    - ... accessible via des adresses,
-
-  +------+----------+----------+------+----------+------+------+
-  | bits | 00110101 | 10010000 | .... | 00110011 | .... | .... |
-  +======+==========+==========+======+==========+======+======+
-  | addr | 2000     | 2001     | .... | 4000     | .... | .... |
-  +------+----------+----------+------+----------+------+------+
-
-    - ... gérée par le système d'exploitation.
-    - ... séparée en deux parties: **la pile** et **le tas**.
-
-## Une variable
-
-* Une variable, `type a = valeur`{.C}, possède:
-    - un type (`char`{.C}, `int`{.C}, ...),
-    - un contenu (une séquence de bits qui encode `valeur`{.C}),
-    - une adresse mémoire (accessible via `&a`{.C}),
-    - une portée.
-
-
-# Représentation des variables en mémoire (2/N)
-
-![Les variables en mémoire.](figs/memory.svg){#fig:memory width=100%}
-
-# Les pointeurs (1/N)
-
-- Un pointeur est une adresse mémoire.
+# Structures de contrôle: `switch`{.C} .. `case`{.C} (1/2)
 
 ```C
-    type *id;
+switch (expression) {
+    case constant-expression:
+        instructions;
+        break; // optionnel
+    case constant-expression:
+        instructions;
+        break; // optionnel
+    // ...
+    default:
+        instructions;
+}
 ```
-- Pour interpréter le contenu de ce qu'il pointe, il doit être typé.
-- Un pointeur n'est rien d'autre qu'un entier (64bit sur x86-64, soit 8 octets).
-- Un pointeur peut être **déréférencé**: on accède à la valeur située à l'adresse mémoire sur laquelle il pointe.
+
+**Que se passe-t-il si `break`{C} est absent?**
+
+# Structures de contrôle: `switch`{.C} .. `case`{.C} (2/2)
 
 ```C
-    char *c; // déclaration pointeur de char
-    *c = 'a'; // assign. 'a' à valeur pointée par c
-    c = 1000; // on modifie l'adresse pointée par c
-    char d = *c; // on lit la valeur pointée par c. UB!
+int x = 0;
+switch (x) {
+    case 0:
+    case 1:
+        printf("0 ou 1\n");
+        break;
+    case 2:
+        printf("2\n");
+        break;
+    default:
+        printf("autre\n");
+}
 ``` 
 
-- `NULL`{.C} (ou `0`{.C}) est la seule adresse **toujours** invalide.
+**Dangereux, mais c'est un moyen d'avoir un "ou" logique dans un case.**
 
-# Les pointeurs (2/N)
+# Quiz: `switch ... case`{.C}
 
-![Les pointeurs, le déréférencement, et la mémoire.](figs/memory_deref.svg){#fig:memory width=100%}
+## [Quiz: `switch ... case`{.C}](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033916)
 
-# Les pointeurs (3/N)
+# Structures de contrôle: `for`{.C} (1/2)
 
-- Permettent d'accéder à une valeur avec une indirection.
+## La boucle `for`{.C}
 
 ```C
-    int a = 2;
-    int *b = &a;
-    *b = 7; // on met 7 dans la case pointée par b
-            // ici  a == 7 aussi
-    a = -2; // ici *b == -2 aussi
+for (expression1; expression2; expression3) {
+    instructions;
+}
 ```
 
-- Permettent d'avoir plusieurs chemins d'accès à une valeur.
-- Lire **et** écrire en même temps dans un bout de mémoire devient possible: **danger**.
+## La boucle `for`{.C}
 
-# Quiz: Les pointeurs
+```C
+int sum = 0; // syntaxe C99
+for (int i = 0; i < 10; i++) {
+    sum += i;
+}
 
-## [Quiz: Les pointeurs](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1038526)
+for (int i = 0; i != 1; i = rand() % 4) { // ésotérique
+    printf("C'est plus ésotérique.\n");
+}
+```
 
-# La fonction `sizeof()` (1/N)
+# Structures de contrôle: `continue`{.C}, `break`{.C} (2/2)
 
-- La fonction `sizeof()`{.C} permet de connaître la taille en octets:
-    - d'une valeur,
-    - d'un type,
-    - d'une variable.
-- Soit `int a = 2`{.C}, sur l'architecture x86_64 que vaut:
-    - `sizeof(a)`{.C}?
-    - `sizeof(&a)`{.C}?
-- Soit `char b = 2`{.C},
-    - `sizeof(b)`{.C}?
-    - `sizeof(&b)`{.C}?
+- `continue`{.C} saute à la prochaine itération d'une boucle.
 
-# La fonction `sizeof()` (2/N)
+    ```C
+    int i = 0;
+    while (i < 10) {
+        if (i == 3) {
+            continue;
+        }
+        printf("%d\n", i);
+        i += 1;
+    }
+    ```
 
-- Réponses:
-    - `sizeof(a) == 4`{.C}, `int`{.C} entier 32 bits.
-    - `sizeof(&a) == 8`{.C}, une adresse est de 64 bits.
-    - `sizeof(b) == 1`{.C}, `char`{.C} entier 8 bits.
-    - `sizeof(&b) == 8`{.C}, une adresse est de 64 bits.
+- `break`{.C} quitte le bloc itératif courant d'une boucle.
 
+    ```C
+    for (int i = 0; i < 10; i++) {
+        if (i == 3) {
+            break;
+        }
+        printf("%d\n", i);
+    }
+    ```
 
-# Les fonctions (1/N)
+# Les fonctions (1/7)
 
 - Les parties indépendantes d'un programme.
 - Permettent de modulariser et compartimenter le code.
@@ -112,7 +107,7 @@
     }
     ```
 
-# Les fonctions (2/N)
+# Les fonctions (2/7)
 
 ## Exemple
 
@@ -130,7 +125,7 @@ int main() {
 }
 ```
 
-# Les fonctions (3/N)
+# Les fonctions (3/7)
 
 - Il existe un type `void`{.C}, "sans type", en C.
 - Il peut être utilisé pour signifier qu'une fonction ne retourne rien, ou qu'elle n'a pas d'arguments.
@@ -148,7 +143,7 @@ int main() {
     }
     ```
 
-# Les fonctions (4/N)
+# Les fonctions (4/7)
 
 ## Prototypes de fonctions
 
@@ -167,7 +162,7 @@ int main() {
     }
     ```
 
-# Les fonctions (5/N)
+# Les fonctions (5/7)
 
 ## Arguments de fonctions
 
@@ -189,7 +184,7 @@ int main() {
     }
     ```
 
-# Les fonctions (6/N)
+# Les fonctions (6/7)
 
 ## Arguments de fonctions: pointeurs
 
@@ -198,7 +193,7 @@ int main() {
 - Un **pointeur** vers une variable entière a le type, `int *x`{.C}.
 - La syntaxe `*x`{.C} sert à **déréférencer** le pointeur (à accéder à la mémoire pointée).
 
-# Les fonctions (7/N)
+# Les fonctions (7/7)
 
 ## Exemple
 
@@ -251,7 +246,7 @@ int main() {
 }
 ``` -->
 
-# La fonction `main()` (1/N)
+# La fonction `main()` (1/2)
 
 ## Généralités
 
@@ -262,7 +257,7 @@ int main() {
 - La valeur de retour peut être lue par le shell qui a exécuté le programme.
 - `EXIT_SUCCESS`{.C} et `EXIT_FAILURE`{.C} (de `stdlib.h`) sont des valeurs de retour **portables** de programmes C. 
 
-# La fonction `main()` (2/N)
+# La fonction `main()` (2/2s)
 
 ## Exemple
 
@@ -286,7 +281,7 @@ $ if [ $? -eq 0 ]; then echo "OK" ; else echo "ERROR"; fi
 ERROR # si tout s'est mal passé
 ```
 
-# Les tableaux (1/N)
+# Les tableaux (1/6)
 
 ## Généralités
 
@@ -301,7 +296,7 @@ ERROR # si tout s'est mal passé
 - 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)
+# Les tableaux (2/6)
 
 ## Exemple
 
@@ -360,7 +355,7 @@ int main(void) {
 	return 0;
 }
 ``` -->
-# Les tableaux (3/N)
+# Les tableaux (3/6)
 
 ## Itérer sur les éléments d'un tableau
 
@@ -382,7 +377,7 @@ do {
 ```
 
 
-# Les tableaux (4/N)
+# Les tableaux (4/6)
 
 ## Les tableaux comme argument
 
@@ -405,7 +400,7 @@ do {
     }
     ```
 
-# Les tableaux (5/N)
+# Les tableaux (5/6)
 
 ## Quels sont les bugs dans ce code?
 
@@ -426,7 +421,7 @@ int main(void) {
 }
 ```
 
-# Les tableaux (6/N)
+# Les tableaux (6/6)
 
 ## Quels sont les bugs dans ce code?
 

base_3.md

@@ -2,6 +2,100 @@
 % Inspirés des slides de F. Glück
 % 2 octobre 2019
 
+# Représentation des variables en mémoire (1/N)
+
+## La mémoire
+
+* La mémoire est:
+    - ... un ensemble de bits,
+    - ... accessible via des adresses,
+
+  +------+----------+----------+------+----------+------+------+
+  | bits | 00110101 | 10010000 | .... | 00110011 | .... | .... |
+  +======+==========+==========+======+==========+======+======+
+  | addr | 2000     | 2001     | .... | 4000     | .... | .... |
+  +------+----------+----------+------+----------+------+------+
+
+    - ... gérée par le système d'exploitation.
+    - ... séparée en deux parties: **la pile** et **le tas**.
+
+## Une variable
+
+* Une variable, `type a = valeur`{.C}, possède:
+    - un type (`char`{.C}, `int`{.C}, ...),
+    - un contenu (une séquence de bits qui encode `valeur`{.C}),
+    - une adresse mémoire (accessible via `&a`{.C}),
+    - une portée.
+
+
+# Représentation des variables en mémoire (2/N)
+
+![Les variables en mémoire.](figs/memory.svg){#fig:memory width=100%}
+
+# Les pointeurs (1/N)
+
+- Un pointeur est une adresse mémoire.
+
+    ```C
+    type *id;
+    ```
+- Pour interpréter le contenu de ce qu'il pointe, il doit être typé.
+- Un pointeur n'est rien d'autre qu'un entier (64bit sur x86-64, soit 8 octets).
+- Un pointeur peut être **déréférencé**: on accède à la valeur située à l'adresse mémoire sur laquelle il pointe.
+
+    ```C
+    char *c; // déclaration pointeur de char
+    *c = 'a'; // assign. 'a' à valeur pointée par c
+    c = 1000; // on modifie l'adresse pointée par c
+    char d = *c; // on lit la valeur pointée par c. UB!
+    ```
+
+- `NULL`{.C} (ou `0`{.C}) est la seule adresse **toujours** invalide.
+
+# Les pointeurs (2/N)
+
+![Les pointeurs, le déréférencement, et la mémoire.](figs/memory_deref.svg){#fig:memory width=100%}
+
+# Les pointeurs (3/N)
+
+- Permettent d'accéder à une valeur avec une indirection.
+
+    ```C
+    int a = 2;
+    int *b = &a;
+    *b = 7; // on met 7 dans la case pointée par b
+            // ici  a == 7 aussi
+    a = -2; // ici *b == -2 aussi
+    ```
+
+- Permettent d'avoir plusieurs chemins d'accès à une valeur.
+- Lire **et** écrire en même temps dans un bout de mémoire devient possible: **danger**.
+
+# Quiz: Les pointeurs
+
+## [Quiz: Les pointeurs](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1038526)
+
+# La fonction `sizeof()` (1/N)
+
+- La fonction `sizeof()`{.C} permet de connaître la taille en octets:
+    - d'une valeur,
+    - d'un type,
+    - d'une variable.
+- Soit `int a = 2`{.C}, sur l'architecture x86_64 que vaut:
+    - `sizeof(a)`{.C}?
+    - `sizeof(&a)`{.C}?
+- Soit `char b = 2`{.C},
+    - `sizeof(b)`{.C}?
+    - `sizeof(&b)`{.C}?
+
+# La fonction `sizeof()` (2/N)
+
+- Réponses:
+    - `sizeof(a) == 4`{.C}, `int`{.C} entier 32 bits.
+    - `sizeof(&a) == 8`{.C}, une adresse est de 64 bits.
+    - `sizeof(b) == 1`{.C}, `char`{.C} entier 8 bits.
+    - `sizeof(&b) == 8`{.C}, une adresse est de 64 bits.
+
 # Types complexes: `struct`{.C} (1/N)
 
 ## Généralités