added cli and 2024

slides/examen.md

+---
+title: "Précisions pour l'examen"
+date: "2024-11-06"
+---
+
+# Administration
+
+- L'examen se déroule sur `nexus`.
+- L'examen dure au plus 4h (il est prévu pour 3 exceptions jusqu'à 4).
+- Votre code devra être dans le répertoire prévu à cet effet.
+- Chaque exercice dans un répertoire (`ex1`, `ex2`, `ex3`, ...).
+- Chaque exercice doit posséder son propre `Makefile` pour la compilation.
+  - Il est impératif de compiler avec les warnings.
+  - Vous devez être capables d'écrire la lifne de compilation de votre code.
+
+# Documents
+
+- On fournit:
+  - Les slides d'algorithmique.
+  - Les slides de programmation séquentielle.
+- Vous pouvez avoir:
+  - Une feuille A4 recto-verso ***manuscrite***.
+
+# Les exercices
+
+- Deux ou trois parties à chaque énoncé:
+  - Une partie "théorique" qui décrit les structures de données et fonctionnalités.
+  - Une partie "technique" qui propose un exemple d'exécution de votre programme avec entrées et sorties.
+  - Une partie "exemple" (pas obligatoire) où d'autres exemples sont donnés afin de tester l'exécution de votre programme.
+- Votre code doit avoir **exactement** le comportement des exemples donnés **sous peine de sanctions**.
+- Chaque code doit être **dans un unique fichier .c** (`ex1.c`, `ex2.c`, ...).
+- Donc **inutile** et **interdit** d'écrire d'autres fichiers
+
+# Évaluation (technique)
+
+- L'évaluation se base surtout sur des critères de fonctionnement: 
+  - le code compile-t-il? (on regarde même pas si la réponse est non)
+  - s'exécute-t-il? (on regarde un peu)
+  - le code demandé est-il réalisé?
+  - donne-t-il des résultats corrects?
+  - votre code possède-t-il des comportements indéfinis?
+- Si vous laissez des warnings vous serez pénalisé·e·s.
+
+# Évaluation (style)
+
+- Le code est-il joli?
+  - Présentation (indentation cohérente, variables nommées de façon raisonnable).
+  - Modularité (utilisation de fonctions).
+  - Pas de variables globales inutiles.
+  - Utilisation de boucles, structures de contrôle, struct, ...
+  - Fonctions récursives, ...
+
+# Les exemples
+
+- Chaque exemple contient:
+  - un input à rentrer à la ligne de commande (on peut copier-coller l'input de l'énoncé).
+  - un output à écrire dans le terminal (on peut comparer la sortie avec celle de l'énoncé).
+- La structure de l'input doit être **exactement** la même que celle décrite dans l'énoncé.
+- Pour l'input il faut impérativement utiliser `argc` et `argv[]`.
+- L'output de vos exercices doit être celui de l'énoncé.
+
+Et maintenant place à des exemples (simplifiés)!
+
+# Exercice 1
+
+Ce programme prend en argument deux entiers et affiche
+leur somme sur une nouvelle ligne.
+
+## Exemple
+
+```bash
+./prog 12 19
+
+31
+```
+
+# Exercice 2
+
+\footnotesize
+
+Ce programme prend en argument un nombre entier `N` puis des nombres à virgule flottante.
+Il y aura exactement `N` nombres à virgule flottante.
+Ensuite, votre programme multiplie chaque nombre à virgule flottante par deux et affiche la somme
+sur une nouvelle ligne suivi de CHF.
+
+## Exemple
+
+```bash
+./prog 12 12.2 45.5 1.5 65.1 89.4 567.6 112.8 67.0 35.1 112.2 3.3 9.8
+
+2243.000000 CHF
+```
+
+# Exercice 3
+
+Ce programme prend en argument 2 chaînes de caractères (longueur max de 80),
+les sépare au milieu et retourne les 4 chaînes chacune sur une nouvelle ligne
+(si la longueur N est paire on sépare en 2 chaînes de longueur N/2, sinon la première
+aura une longueur de N/2 et la seconde N/2+1).
+
+## Exemple
+
+```bash
+./prog abcdefgh asdfghjkl
+
+abcd
+efgh
+asdf
+ghjkl
+```

slides/ligne_de_commande_c.md

+---
+title: "La ligne de commande"
+date: "2024-11-06"
+---
+
+# La ligne de commande (1/4)
+
+* Ou comment passer des arguments à un programme en C.
+
+## Point d'entrée d'un programme
+
+- Le point d'entrée est la fonction `main()`{.C}.
+- Elle peut être déclarée de 4 façon différentes:
+    1. `void main()`{.C}.
+    2. `int main()`{.C}.
+    3. `void main(int argc, char **argv)`{.C}.
+    4. `int main(int argc, char *argv[])`{.C}.
+    
+- `argc`{.C} est le nombre d'arguments passés à la ligne de commande: **le premier est celui du programme lui-même**.
+- `argv`{.C} est un tableau de chaînes de caractères passés sur la ligne de commande.
+
+# La ligne de commande (2/4)
+
+## Exemple d'utilisation
+
+Pour la fonction dans le programme `prog`
+
+```C
+int main(int argc, char **argv)
+```
+
+Pour l'exécution suivante on a 
+
+```bash
+./prog -b 50 file.txt
+```
+
+```C
+argc == 4
+argv[0] == "prog"
+argv[1] == "-b"
+argv[2] == "50"
+argv[3] == "file.txt"
+```
+
+# La ligne de commande (3/4)
+
+## Conversion des arguments
+
+- Les arguments sont toujours stockés comme des **chaînes de
+  caractères**.
+- Peu pratique si on veut manipuler des valeurs numériques.
+- Fonctions pour faire des conversions:
+
+    ```C
+    int atoi(const char *nptr);  // de la chaîne en entier
+    double atof(const char *nptr); // de la chaîne en nombre à virgule flottante
+    int snprintf(char *str, size_t size, 
+                 const char *format, ...); 
+    // str: buffer, size: taille en octets max à copier,
+    // format: cf printf(), ret: nombre de char lus
+    ```
+
+# La ligne de commande (4/4)
+
+## Exemple d'utilisation
+
+\footnotesize
+
+```C
+#include <stdio.h>
+#include <stdlib.h>
+#include <libgen.h>
+int main(int argc, char **argv) {
+    if (argc != 3) {
+        char *progname = basename(argv[0]);
+        fprintf(stderr, "usage: %s name age\n", progname);
+        return EXIT_FAILURE;
+    }
+    // argv[0] est le nom du programme on l'ignore
+    // le 1er argument est une chaîne de caractères (pas de conversion)
+    char *name = argv[1]; 
+    int age = atoi(argv[2]); // le 2e argument est un entier (conversion)
+    printf("Hello %s, you are %d years old.\n", name, age);
+    return EXIT_SUCCESS;
+}
+```
+
+. . .
+
+```bash
+$ ./prog Paul 29
+Hello Paul, you are 29 years old.
+```
+