maj 28

slides/boucles_conditions.md

+---
+title: "Boucles et conditions"
+date: "2023-09-28"
+patat:
+    wrap: true
+    margins:
+        left: 10
+        right: 10
+---
+
+# Quiz
+
+\footnotesize
+
+## Que fait le code suivant?
+
+```C
+#include <stdio.h>
+#include <stdlib.h>
+int main() {
+  printf("Enter n: ");
+  int n = 0;
+  scanf("%d", &n);
+  int res = 0;
+  for (int i = 0; i <= n; ++i) {
+    res += i;
+  }
+  printf("For = %d, the result is %d\n", n, res);
+  if (res != n * (n+1) / 2) {
+    printf("Error: the answer is wrong.\n");
+    return EXIT_FAILURE;
+  }
+  return EXIT_SUCCESS;
+}
+```
+
+# Génération d'un exécutable
+
+- Pour pouvoir être exécuté un code C doit être d'abord compilé (avec `gcc` ou `clang`).
+- Pour un code `prog.c` la compilation "minimale" est
+
+    ```bash
+    $ clang prog.c
+    $ ./a.out # exécutable par défaut
+    ```
+
+- Il existe une multitude d'options de compilation:
+
+    ```bash
+    $ clang -std=c11 -Wall -Wextra prog.c -o prog
+    ```
+    1. `-std=c11` utilisation de C11.
+    2. `-Wall` et `-Wextra` activation des warnings.
+    3. `-o` défini le fichier exécutable à produire en sortie.
+
+# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (1/2)
+
+\footnotesize
+
+## Syntaxe
+
+```C
+if (expression) {
+    instructions;
+} else if (expression) { // optionnel
+                         // il peut y en avoir plusieurs
+    instructions;
+} else {
+    instructions; // optionnel
+}
+```
+
+```C
+if (x) { // si x s'évalue à `vrai`
+    printf("x s'évalue à vrai.\n");
+} else if (y == 8) { // si y vaut 8
+    printf("y vaut 8.\n");
+} else {
+    printf("Ni l'un ni l'autre.\n");
+}
+```
+
+
+# Structures de contrôle: `continue`{.C}, `break`{.C}
+
+\footnotesize
+
+- `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);
+    }
+    ```
+
+# La fonction `main()` (1/2)
+
+## Généralités
+
+- Point d'entrée du programme.
+- Retourne le code d'erreur du programme:
+    - 0: tout s'est bien passé.
+    - Pas zéro: problème.
+- 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/2)
+
+## Exemple
+
+```C
+int main() {
+    // ...
+    if (error)
+	    return EXIT_FAILURE;
+    else
+	    return EXIT_SUCCESS;
+}
+```
+
+- Le code d'erreur est lu dans le shell avec `$?`{.bash}
+
+```bash
+$ ./prog
+$ echo $?
+0 # tout s'est bien passé par exemple
+$ if [ $? -eq 0 ]; then echo "OK"; else echo "ERROR"; fi
+ERROR # si tout s'est mal passé
+```
+
+# Entrées/sorties: `printf()`{.C} (1/2)
+
+## Généralités
+
+- La fonction `printf()`{.C} permet d'afficher du texte sur le terminal:
+
+    ```C
+    int printf(const char *format, ...);
+    ```
+- Nombre d'arguments variables.
+- `format`{.C} est le texte, ainsi que le format (type) des variables à afficher.
+- Les arguments suivants sont les expressions à afficher.
+
+# Entrées/sorties: `printf()`{.C} (2/2)
+
+## Exemple
+
+```C
+#include <stdio.h>
+#include <stdlib.h>
+int main() {
+    printf("Hello world.\n");
+    int val = 1;
+    // %d => int
+    printf("Hello world %d time.\n", val); 
+    // %f => float
+    printf("%f squared is equal to %f.\n", 
+           2.5, 2.5*2.5); 
+    // %s => string
+    printf("Hello world %s.\n", "Hello world"); 
+    return EXIT_SUCCESS;
+}
+```
+
+# Entrées/sorties: `scanf()`{.C} (1/2)
+
+## Généralités
+
+- La fonction `scanf()`{.C} permet de lire du texte formaté entré au clavier:
+
+    ```C
+    int scanf(const char *format, ...);
+    ```
+
+- `format`{.C} est le format des variables à lire (comme `printf()`{.C}).
+- Les arguments suivants sont les variables où sont stockées les valeurs lues.
+
+# Entrées/sorties: `scanf()`{.C} (2/2)
+
+## Exemple
+
+```C
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+    printf("Enter 3 numbers: \n");
+    int i, j, k;
+    scanf("%d %d %d", &i, &j, &k); // !!! &
+    printf("You entered: %d %d %d\n", i, j, k);
+    
+    return EXIT_SUCCESS;
+}
+```
+
+# Nombres aléatoires: `rand()`, `srand()`{.C} (2/2)
+
+\footnotesize
+
+```
+$ man 3 rand
+The  rand()  function  returns  a  pseudo-random  integer  
+in  the  range  0  to RAND_MAX inclusive (i.e., the 
+mathematical range [0, RAND_MAX]).
+```
+
+## Exemple
+
+```C
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+int main() {
+    srand(0);          // every run will be identical
+    srand(time(NULL)); // every run will be be different
+    for (int i = 0; i < 50; ++i) {
+        printf("%d\n", rand() % 50); // à quoi sert % 50?
+    }
+    return EXIT_SUCCESS;
+}
+```
+
+# Le cas du nombre secret
+
+## But du programme
+
+* Faire chercher un nombre aléatoire,
+* Le nombre est compris entre 0 et une borne max.
+
+## Quelles sont les étapes?
+
+
+1. Donner une borne maximale à l'ordinateur, MAX.
+
+. . .
+
+2. Faire tirer un nombre aléatoire à l'ordinateur entre 0 et MAX-1.
+
+. . .
+
+3. Le·la joueur·se joue un nombre.
+
+. . .
+
+4. L'ordinateur vérifie la réponse:
+
+    * Si correct le jeu est fini,
+    * Sinon indiquer si le nombre secret est plus grand ou plus petit et revenir à 3.
+
+# La fin
+
+1. Y a-t-il des questions?
+
+. . .
+
+2. Si oui, répondre et revenir à 1, sinon aller faire l'exercice en A432/433/406.

slides/command_line.md

+---
+title: "Introduction à la l'interface en ligne de commande"
+date: "2023-09-28"
+---
+
+# Introduction
+
+## Généralités
+
+* *Command line interface* (CLI) en anglais.
+* Interface textuelle vers l'ordinateur.
+* Peut s'appeler le *shell*, le *terminal*, la *console*, ...
+* Semble obscure, mais est très pratique (automatisation de tâches, copier-coller, ...).
+* Vous devrez l'utiliser tout au long de vos études.
+* Existe sous Linux, MacOS, et même Windows (les commandes peuvent varier!).
+* Ici on ne parlera que de *Linux*.
+
+# A quoi ça sert?
+
+## Équivalent textuel d'un GUI
+
+Toutes les informations obtenues avec une interface graphique, peuvent être obtenues à l'aide de la ligne de commande (liste loin d'être exhaustive):
+
+* Changement d'un répertoire: `cd`{.bash}
+* Affichage du contenu d'un répertoire: `ls`{.bash}
+* Déplacement de fichier: `mv`{.bash}
+* Copie de fichier: `cp`{.bash}
+* Création de répertoire: `mkdir`{.bash}
+* Recherche de fichier: `find`{.bash}
+* Recherche de texte dans un fichier: `grep`{.bash}
+* Etc, etc, etc, etc, etc
+
+## Mais aussi
+
+* Télécharger des documents, compiler, éditer des fichiers, ...
+
+# Ouvrir un terminal
+
+\footnotesize
+
+Dépendant de votre distribution de Linux l'ouverture d'un terminal peut varier.
+
+Ce qui marche *presque* tout le temps:
+
+1. Appuyer sur le bouton `Super` (`Windows`) du clavier.
+2. Commencer à taper "terminal".
+
+![](figs/terminal_open.png){width=100%}
+
+Raccourcis clavier:
+
+* `Ctrl+Alt+T`{.bash}
+* `Super+T`{.bash}
+* Vous pouvez customiser les raccourcis.
+
+# Une fois le terminal ouvert
+
+Vous pouvez taper des commandes puis `Entrée`.
+
+```bash
+$ pwd
+/home/orestis
+```
+
+Exemple: `pwd`{.bash} affiche le répertoire courant (**p**rint **w**orking **d**irectory).
+
+**Attention: les commandes sont sensibles à la casse!**
+
+Exemple: `cd`{.bash} change de répertoire (**c**hange **d**irectory).
+
+:::::::::::::: {.columns}
+
+::: {.column width="45%"}
+
+```bash
+$ pwd
+/home/orestis
+$ cd ..
+$ pwd
+/home
+```
+
+:::
+::: {.column width="45%"}
+
+```bash
+$ cd orestis
+$ pwd
+/home/orestis
+$ cd ../..
+$ pwd
+/
+```
+
+:::
+::::::::::::::
+
+# Remarque: chemins relatifs ou absolus
+
+Un *chemin* est relatif à moins que le chemin commence par `/` ou `~`.
+
+```bash
+$ pwd
+/home/orestis
+$ cd Downloads
+$ pwd
+/home/orestis/Downloads
+$ cd /tmp
+$ pwd
+/tmp
+$ cd ~/Downloads
+$ pwd
+/home/orestis/Downloads
+```
+
+# Ouvrir un éditeur de texte et éditer un ficher
+
+* Installer un éditeur de texte: `codium`, `vim`, `nvim`, ...
+* Ouvrir l'éditeur de texte (ici codium):
+
+    ```bash
+    $ codium
+    ```
+* Écrire `Hello World!` dans le fichier et sauver sous `cours.dat`.
+
+* Ou alors utiliser `nano`, `vi`, `nvim`, ...
+
+    ```bash
+    $ nano cours.dat
+    ```
+* Écrire `Hello World!` puis `Ctrl+X` et `Y`.
+
+# Quelques commandes utiles (1/3)
+
+\footnotesize
+
+## `mkdir`, création de répertoire
+
+```bash
+$ mkdir tmp
+$ cd tmp
+$ pwd
+/home/orestis/tmp
+```
+
+## `ls`, affiche le contenu d'un répertoire
+
+```bash
+$ ls
+Desktop  Documents  git  Music     Public     tmp
+Docker   Downloads  go   Pictures  Templates  Videos
+$ ls -ltr
+... # des répertoires
+drwxr-xr-x  3 orestis orestis 4096 31 aoû 09:54 Documents
+drwxr-xr-x 11 orestis orestis 4096  7 sep 15:59 Downloads
+drwxr-xr-x  2 orestis orestis 4096  9 sep 11:14 Pictures
+drwxr-xr-x  2 orestis orestis 4096  9 sep 12:41 tmp
+-rw-r--r--  1 orestis orestis    6  9 sep 12:52 cours.dat
+```
+
+# Quelques commandes utiles (2/3)
+
+## `cp`{.bash}, copie de fichiers/répertoires
+
+```bash
+$ cp cours.dat tmp/ # cp cours.dat -> tmp
+$ ls tmp # affiche le rép tmp
+cours.dat
+$ cp -r tmp tmp2 # option -r => recursive
+$ ls
+cours.dat  Docker     Downloads  go     Pictures  Templates  tmp2
+Desktop    Documents  git        Music  Public    tmp        Videos
+```
+
+## `mv`{.bash}, déplacement de fichiers/répertoires
+
+```bash
+$ ls tmp
+$ mv cours.dat tmp # déplace cours.dat -> tmp
+$ ls tmp
+cours.dat
+```
+
+# Quelques commandes utiles (3/3)
+
+## `rm`{.bash}, effacer des fichiers/répertoires
+
+```bash
+$ ls tmp
+cours.dat
+$ rm tmp/cours.dat
+$ ls tmp
+$ rm -r tmp tmp2
+$ ls
+Desktop  Documents  git  Music     Public     Videos
+Docker   Downloads  go   Pictures  Templates
+```
+
+# La touche `tab`{.bash}
+
+Probablement la touche la plus utile du clavier:
+
+* permet la complétion d'une commande.
+* permet la complétion d'un nom de fichier.
+* permet d'afficher les complétions possibles.
+
+Fait gagner un temps considérable.
+
+# Éditeurs de texte
+
+Il existe différents éditeurs de texte qui pourraient être utiles:
+
+* `vscode`{.bash} ou `codium`{.bash} (la version sans l'espionnage M\$)
+* `vim`{.bash}
+* `geany`{.bash}
+* `gedit`{.bash}
+* ...
+
+Ne vous reposez pas trop sur l'éditeur pour tout faire à votre place.
+