Skip to content
Snippets Groups Projects
Verified Commit d3529a52 authored by orestis.malaspin's avatar orestis.malaspin
Browse files

removed old slides to start fresh

parent ac81f962
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 0 additions and 17181 deletions
slides/allocation_dynamique.md deleted 100644 → 0
+ 0
− 261
View file @ ac81f962
---
title: "Allocation dynamique de mémoire"
date: "2022-11-22"
---
# Allocation dynamique de mémoire (1/7)
- La fonction `malloc`{.C} permet d'allouer dynamiquement (pendant l'exécution du programme) une zone de mémoire contiguë.
```C
#include <stdlib.h>
void *malloc(size_t size);
```
- `size`{.C} est la taille de la zone mémoire **en octets**.
- Retourne un pointeur sur la zone mémoire ou `NULL`{.C} en cas d'échec: **toujours vérifier** que la valeur retournée est `!= NULL`{.C}.
- Le *type* du retour est `void *`{.C} (un pointeur de type quelconque).
# Allocation dynamique de mémoire (2/7)
- On peut allouer et initialiser une `fraction_t`{.C}:
```C
fraction_t *frac = malloc(sizeof(fraction_t));
frac->num = 1;
frac->denom = -1;
```
- La zone mémoire **n'est pas** initialisée.
- Désallouer la mémoire explicitement, sinon **fuites mémoires**.
- Il faut connaître la **taille** des données à allouer.
![La représentation mémoire de `fraction_t` et fuites.](figs/pointer_struct_ok.svg){width=100%}
# Allocation dynamique de mémoire (3/7)
- La fonction `free()`{.C} permet de libérer une zone préalablement allouée avec `malloc()`{.C}.
```C
#include <stdlib.h>
void free(void *ptr);
```
- A chaque `malloc()`{.C} doit correspondre exactement un `free()`{.C}.
- Si la mémoire n'est pas libérée: **fuite mémoire** (l'ordinateur plante quand il y a plus de mémoire).
- Si la mémoire est **libérée deux fois**: *seg. fault*.
- Pour éviter les mauvaises surprises mettre `ptr`{.C} à `NULL`{.C} après
libération.
# Allocation dynamique de mémoire (4/7)
## Tableaux dynamiques
- Pour allouer un espace mémoire de 50 entiers: un tableau
```C
int *p = malloc(50 * sizeof(int));
for (int i = 0; i < 50; ++i) {
p[i] = 0;
}
```
## Arithmétique de pointeurs
- Parcourir la mémoire différemment qu'avec l'indexation
```C
int *p = malloc(50 * sizeof(int));
// initialize somehow
int a = p[7];
int b = *(p + 7); // on avance de 7 "int"
p[0] == *p; // le pointeur est le premier élément
```
# Allocation dynamique de mémoire (5/7)
## Arithmétique de pointeurs
![L'arithmétique des pointeurs.](figs/pointer_arithmetics.svg){width=100%}
## Quelle est la complexité de l'accès à une case d'un tableau?
. . .
$$
\mathcal{O}(1).
$$
# Allocation dynamique de mémoire (6/7)
## Pointeur de pointeur
- Tout comme une valeur a une adresse, un pointeur a lui-même une adresse:
```C
int a = 2;
int *b = &a;
int **c = &b;
```
- En effet, un pointeur est aussi une variable (une variable qui contient une adresse mémoire).
- Chaque `*`{.C} rajoute une indirection.
# Allocation dynamique de mémoire (6/7)
## Pointeur de pointeur
![Les références de pointeurs.](figs/double_pointeur.svg){height=100%}
# Allocation dynamique de mémoire (7/7)
- Avec `malloc()`, on peut allouer dynamiquement des tableaux de pointeurs:
```C
int **p = malloc(50 * sizeof(int*));
for (int i = 0; i < 50; ++i) {
p[i] = malloc(70 * sizeof(int));
}
int a = p[5][8]; // on indexe dans chaque dimension
```
- Ceci est une matrice (un tableau de tableaux).
# Tableau dynamique en argument d'une fonction
## Implémenter la fonction ci-dessous
```C
int32_t *p = malloc(50 * sizeof(*p));
initialize_to(p, 50, -1); // initialise un tableau à -1
free(p); // ne pas oublier
```
. . .
```C
void initialize_to(int32_t *p, size_t size, int32_t val) {
for (size_t i = 0; i < size; ++i) {
p[i] = val;
}
}
```
# Tableau dynamique retourné d'une fonction
## Implémenter la fonction ci-dessous
```C
// alloue un tableau de taille 50 et l'initialise à -1
int32_t *p = initialize_to(50, -1);
free(p); // ne pas oublier
```
. . .
```C
uint32_t initialize_to(size_t size, int32_t val) {
int32_t *p = malloc(size * sizeof(*p));
for (size_t i = 0; i < size; ++i) {
p[i] = val;
}
return p;
}
```
## Pourquoi on peut retourner un tableau dynamique et pas un statique?
. . .
* Le tableau est alloué sur le **tas** et non sur la **pile**.
* La mémoire est gérée manuellement sur le tas, automatiquement sur la pile.
# Les *sanitizers*
Problèmes mémoire courants:
* Dépassement de capacité de tableaux.
* Utilisation de mémoire non allouée.
* Fuites mémoire.
* Double libération.
Outils pour leur détection:
* Valgrind (outil externe).
* Sanitizers (ajouts de marqueurs à la compilation).
Ici on utilise les sanitizers (modification de la ligne de compilation, modifiez donc vos *Makefile*):
```bash
gcc -o main main.c -g -fsanitize=address -fsanitize=leak
```
**Attention:** Il faut également faire l'édition des liens avec les sanitizers.
# Questions
## Que fait le code suivant?
```C
int *p = malloc(50 * sizeof(int));
p[10] = 1;
```
. . .
* On alloue de la place pour 50 entiers.
* On initialise le 11ème élément du tableau à 1.
* Les autres éléments sont non-initialisés.
# Questions
## Que fait le code suivant?
```C
float *p = malloc(50);
p[20] = 1.3;
```
. . .
* On déclare un pointeur de floats de taille 50 octets.
* Mais il ne peut contenir que `50 / 4` floats (un float est composé de 32 bits).
* On dépasse la capacité de la mémoire allouée: comportement indéfini.
# Questions
* Soit le code suivant
```C
int *p = malloc(50 * sizeof(int));
for (int i = 0; i < 50; ++i) {
p[i] = 0;
}
```
* Le réécrire en utilisant uniquement l'arithmétique de pointeurs.
. . .
```C
int *p = malloc(50 * sizeof(int));
for (int i = 0; i < 50; ++i) {
*(p+i) = 0;
}
```
# Questions
## Que valent les expressions suivantes?
```C
in32_t *p = malloc(50 * sizeof(int32_t));
sizeof(p);
sizeof(*p);
(p + 20);
*(p + 20);
p[-1];
p[50];
7[p];
```
slides/boucles_conditions.md deleted 100644 → 0
+ 0
− 272
View file @ ac81f962
---
title: "Boucles et conditions"
date: "2022-09-27"
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 deleted 100644 → 0
+ 0
− 220
View file @ ac81f962
---
title: "Introduction à la l'interface en ligne de commande"
date: "2022-09-27"
---
# 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.
slides/compilation_make.md deleted 100644 → 0
+ 0
− 403
View file @ ac81f962
---
title: "Compilation séparée et Makefile"
date: "2022-11-01"
patat:
wrap: true
margins:
left: 10
right: 10
---
# Prototypes de fonctions (1/3)
```C
// Prototype, pas d'implémentation, juste la doc
int sum(int size, int tab[size]);
```
## Principes généraux de programmation
- Beaucoup de fonctionnalités dans un code $\Rightarrow$ Modularisation.
- Modularisation du code $\Rightarrow$ écriture de fonctions.
- Beaucoup de fonctions $\Rightarrow$ regrouper les fonctions dans des fichiers séparés.
## Mais pourquoi?
- Lisibilité.
- Raisonnement sur le code.
- Débogage.
## Exemple
- Libraire `stdio.h`: `printf()`{.C}, `scanf()`{.C}, ...
# Prototypes de fonctions (2/3)
- Prototypes de fonctions nécessaires quand:
1. Utilisation de fonctions dans des fichiers séparés.
2. Utilisation de librairies.
- Un prototype indique au compilateur la signature d'une fonction.
- On met les prototypes des fonctions **publiques** dans des fichiers *headers*, extension `.h`.
- Les *implémentations* des fonctions vont dans des fichier `.c`.
# Prototypes de fonctions (3/3)
## Fichier header
- Porte l'extension `.h`
- Contient:
- définitions des types
- prototypes de fonctions
- macros
- directives préprocesseur (cf. plus loin)
- Utilisé pour décrire **l'interface** d'une librairie ou d'un module.
- Un fichier `C` (extension `.c`) utilise un header en *l'important* avec la directive `#include`{.C}:
```C
#include <stdio.h> // dans LD_LIBRARY_PATH
#include "chemin/du/prototypes.h" // explicite
```
# Génération d'un exécutable (1/5)
## Un seul fichier source
![Étapes de génération.](figs/compilation.svg){width=100%}
# Génération d'un exécutable (2/5)
\footnotesize
```bash
gcc proc.c -o prog
```
1. **Précompilation: ** `gcc` appelle `cpp`, le préprocesseur qui effectue de la substitution de texte (`#define`, `#include`, macros, ...) et génère le code `C` à compiler, portant l'extension `.i` (`prog.i`).
2. **Compilation assembleur: ** `gcc` compile le code C en code assembleur, portant l'extension `.s` (`prog.s`).
3. **Compilation code objet: ** `gcc` appelle `as`, l'assembleur, qui compile le code assembleur en code machine (code objet) portant l'extension `.o` (`prog.o`).
4. **Édition des liens: ** `gcc` appelle `ld`, l'éditeur de liens, qui lie le code objet avec les librairies et d'autres codes objet pour produire l'exécutable final (`prog`).
Les différents codes intermédiaires sont effacés automatiquement.
# Génération d'un exécutable (3/5)
## Plusieurs fichiers sources
![Étapes de génération, plusieurs fichiers.](figs/compilation_plusieurs.svg){width=100%}
# Génération d'un exécutable (4/5)
\footnotesize
::: Main
## `main.c`
```C
#include <stdio.h>
#include "sum.h"
int main() {
int tab[] = {1, 2, 3, 4};
printf("sum: %d\n", sum(tab, 4));
return 0;
}
```
:::
:::::::::::::: {.columns}
::: {.column width="45%"}
## `sum.h`
```C
#ifndef _SUM_H_
#define _SUM_H_
int sum(int tab[], int n);
#endif
```
:::
::: {.column width="55%"}
## `sum.c`
```C
#include "sum.h"
int sum(int tab[], int n) {
int s = 0;
for (int i = 0; i < n; i++) {
s += tab[i];
}
return s;
}
```
:::
::::::::::::::
# Génération d'un exécutable (5/5)
La compilation séparée se fait en plusieurs étapes.
## Compilation séparée
1. Générer séparément les fichiers `.o` avec l'option `-c`.
2. Éditer les liens avec l'option `-o` pour générer l'exécutable.
## Exemple
- Création des fichiers objets, `main.o` et `sum.o`
```bash
$ gcc -Wall -Wextra -std=c11 -c main.c
$ gcc -Wall -Wextra -std=c11 -c sum.c
```
- Édition des liens
```bash
$ gcc main.o sum.o -o prog
```
# Préprocesseur (1/2)
\footnotesize
## Généralités
- Première étape de la chaîne de compilation.
- Géré automatiquement par `gcc` ou `clang`.
- Lit et interprète certaines directives:
1. Les commentaires (`//`{.C} et `/* ... */`{.C}).
2. Les commandes commençant par `#`{.C}.
- Le préprocesseur ne compile rien, mais subtitue uniquement du texte.
## La directive `define`{.C}
- Permet de définir un symbole:
```C
#define PI 3.14159
#define _SUM_H_
```
- Permet de définir une macro.
```C
#define NOM_MACRO(arg1, arg2, ...) [code]
```
# Préprocesseur (2/2)
## La directive `include`{.C}
- Permet d'inclure un fichier.
- Le contenu du fichier est ajouté à l'endroit du `#include`{.C}.
- Inclusion de fichiers "globaux" ou "locaux"
```C
#include <file.h> // LD_LIBRARY_PATH
#include "other_file.h" // local path
```
- Inclusions multiples peuvent poser problème: définitions multiples. Les headers commencent par:
```C
#ifndef _VAR_
#define _VAR_
/* commentaires */
#endif
```
# Introduction à `make`
## A quoi ça sert?
- Automatiser le processus de conversion d'un type de fichier à un autre, en *gérant les dépendances*.
- Effectue la conversion des fichiers qui ont changé uniquement.
- Utilisé pour la compilation:
- Création du code objet à partir des sources.
- Création de l'exécutable à partir du code objet.
- Tout "gros" projet utilise `make` (pas uniquement en `C`).
# Utilisation de `make`
\footnotesize
Le programme `make` exécutera la série d'instruction se trouvant dans un `Makefile` (ou `makefile` ou `GNUmakefile`).
## Le `Makefile`
- Contient une liste de *règles* et *dépendances*.
- Règles et dépendances construisent des *cibles*.
- Ici utilisé pour compiler une série de fichiers sources
```
$ gcc -c example.c # + plein d'options..
$ gcc -o example exemple.o # + plein d'options
```
:::::::::::::: {.columns}
::: {.column width="55%"}
## `Makefile`
```bash
example: example.o
gcc -o example example.o
exmaple.o: exmaple.c example.h
gcc -c example.c
```
:::
::: {.column width="45%"}
## Terminal
```bash
$ make
gcc -c example.c
gcc -o example example.o
```
:::
::::::::::::::
# Syntaxe d'un `Makefile` (1/4)
![Un exemple simple de `Makefile`.](figs/ex_makefile.svg){width=100%}
# Syntaxe d'un `Makefile` (2/4)
![La cible.](figs/ex_makefile_cible.svg){width=100%}
# Syntaxe d'un `Makefile` (3/4)
![Les dépendances.](figs/ex_makefile_dep.svg){width=100%}
# Syntaxe d'un `Makefile` (4/4)
![La règle.](figs/ex_makefile_regle.svg){width=100%}
# Principe de fonctionnement
1. `make` cherche le fichier `Makefile`, `makefile` ou `GNUmakefile` dans le répertoire courant.
2. Par défaut exécute la première cible, ou celle donnée en argument.
3. Décide si une cible doit être régénérée en comparant la date de modification (on recompile que ce qui a été modifié).
4. Regarde si les dépendances doivent être régénérées:
- Oui: prend la première dépendance comme cible et recommence à 3.
- Non: exécute la règle.
`make` a un comportement **récursif**.
# Exemple avancé
:::::::::::::: {.columns}
::: {.column width="55%"}
## `Makefile`
```bash
hello: hello.o main.o
gcc hello.o main.o -o hello
hello.o: hello.c hello.h
gcc -Wall -Wextra -c hello.c
main.o: main.c
gcc -Wall -Wextra -c main.c
clean:
rm -f *.o hello
rebuild: clean hello
```
:::
::: {.column width="45%"}
## Un graph complexe
![`Makefile` complexe.](figs/complex_makefile.svg){width=100%}
:::
::::::::::::::
# Factorisation
:::::::::::::: {.columns}
::: {.column width="55%"}
## Ancien `Makefile`
```bash
hello: hello.o main.o
gcc hello.o main.o -o hello
hello.o: hello.c hello.h
gcc -Wall -Wextra -c hello.c
main.o: main.c
gcc -Wall -Wextra -c main.c
clean:
rm -f *.o hello
rebuild: clean hello
```
:::
::: {.column width="45%"}
## Nouveau `Makefile`
```bash
CC=gcc -Wall -Wextra
hello: hello.o main.o
$(CC) $^ -o $@
hello.o: hello.c hello.h
$(CC) -c $<
main.o: main.c
$(CC) -c $<
clean:
rm -f *.o hello
rebuild: clean hello
```
:::
::::::::::::::
# Variables
\footnotesize
## Variables utilisateur
- Déclaration
```bash
id = valeur
id = valeur1 valeur2 valeur3
```
- Utilisation
```bash
$(id)
```
- Déclaration à la ligne de commande
```bash
make CFLAGS="-O3 -Wall"
```
## Variables internes
- `$@` : la cible
- `$^` : la liste des dépendances
- `$<` : la première dépendance
- `$*` : le nom de la cible sans extension
slides/examen.md deleted 100644 → 0
+ 0
− 113
View file @ ac81f962
---
title: "Précisions pour l'examen"
date: "2022-11-29"
---
# Administration
- L'examen dure au plus 4h (il est prévu pour 3 exceptions jusqu'à 4).
- Votre code devra être dans un repo `git`.
- Chaque exercice dans un répertoire (`ex1`, `ex2`, `ex3`, `ex4`).
- Le lien vers votre git devra figurer dans la réponse à chaque exercice.
- Chaque exercice doit posséder son propre `Makefile` pour la compilation.
- Il est impératif de compiler avec les warnings et les sanitizers.
**N'hésitez pas à préparer des templates pour que tout ça aille plus vite.**
# 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`, ...).
# Évaluation (technique)
- L'évaluation se base surtout sur des critères de fonctionnement:
- le code compile-t-il? (on regarde même pas)
- s'exécute-t-il? (on regarde un peu)
- le code demandé est-il réalisé?
- donne-t-il des résultats corrects?
- Si vous laissez des warnings ou des erreurs de sanitizers 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 dans le terminal (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é.
- 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 se trouvant chacun
sur une nouvelle ligne et affiche
la somme des deux entiers en argument sur une nouvelle ligne.
## Exemple
```bash
12
19
31
```
# Exercice 2
\footnotesize
Ce programme prend en argument 12 nombres à virgule flottante se trouvant chacun
sur une nouvelle ligne. Multiplie chaque nombre par deux et affiche leur somme
sur une nouvelle ligne suivi de CHF.
## Exemple
```bash
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 sur des lignes séparées (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
abcdefgh
asdfghjkl
abcd
efgh
asdf
ghjkl
```
slides/fichiers.md deleted 100644 → 0
+ 0
− 153
View file @ ac81f962
---
title: "Lecture/écriture de fichiers"
date: "2022-12-13"
---
# Les fichier en C
* Un fichier en C est représenté par un pointeur de fichier.
```C
#include <stdio.h>
FILE *fp;
```
* `FILE *`{.C} est une structure de donnée *opaque* contenant les informations sur l'état du fichier.
* Il est manipulé à l'aide de fonctions dédiées.
* Le pointeur de fichier est toujours passé *par copie*.
# Manipulations de fichier
* Pour lire/écrire dans un fichier il faut toujours effectuer trois étapes:
1. Ouvrir le fichier (`fopen()`{.C}).
2. Écrire/lire dans le fichier (`fgets()`{.C}, `fputs()`{.C}, `fread()`{.C}, `fwrite()`{.C}, ...).
3. Fermer le fichier (`fclose()`{.C}).
* Nous allons voir brièvement ces trois étapes.
# Ouverture d'un fichier
* L'ouverture d'un fichier se fait avec la fonction `fopen()`{.C}
```C
FILE *fp = fopen(filename, mode);
```
* `filename`{.C} est une chaîne de caractères (incluant le chemin).
* `mode`{.C} est le mode d'ouverture (`"r"`{.C}, `"w"`{.C}, ... voir `man 3 fopen`{.bash}) qui est une chaîne de caractères.
* Si l'ouverture échoue (pas la bonne permission, ou n'existe pas) `fopen()`{.C} retourne `0`.
* **Toujours** tester le retour de `fopen()`{.C}
```C
if (NULL == fp) {
fprintf(stderr, "Can't open output file %s!\n",
filename); // affiche dans le canal d'erreur
exit(EXIT_FAILURE);
}
```
# Fermeture d'un fichier
* Il faut **toujours** fermer un fichier à l'aide de `fclose()`{.C}
```C
FILE *fp = fopen("mon_fichier", "w");
// écritures diverses
fclose(fp);
```
* Les données sont transférées dans une mémoire tampon, puis dans le disques.
* Si la mémoire tampon est pleine, le fichier est fermé, ... les données sont écrites sur le disque.
* Si la mémoire tampon contient encore des données à la fin du programme les données sont **perdues**.
# Lecture d'un fichier (1/2)
```C
char *fgets(char *s, int size, FILE *stream)
```
* Lit une ligne de taille d'au plus `size-1` et la stocke dans `s`, depuis `stream`.
* Retourne `s` ou `NULL` si échoue.
```C
FILE *fp = fopen("text.txt", "r");
char buffer[100];
fgets(buffer, 37, fp);
// lit 36 caractères au plus et les écrit dans buffer
// s'arrête si rencontre EOF, ou "\n".
// ajoute un "\0" terminal
fclose(fp);
```
# Lecture d'un fichier (2/2)
```C
size_t fread(void *ptr, size_t size, size_t nmemb,
FILE *stream)
```
* Lit `nmemb` éléments de taille `size` octets et les écrit à l'adresse `ptr` dans le fichier `stream`.
* Retourne le nombre d'éléments lus.
```C
FILE *fp = fopen("doubles.bin", "rb");
double buffer[100];
size_t num = fread(buffer, sizeof(double), 4, fp);
// lit 4 double, se trouvant dans le fichier fp au
// format binaire et les écrit dans buffer, puis
// retourne 4
fclose(fp);
```
# Écriture dans un fichier (1/2)
```C
int fprintf(FILE *stream, const char *format, ...)
```
* Écrit la chaîne de caractères `format` dans le fichier stream.
* `format` a la même syntaxe que pour `printf()`.
* Retourne le nombre de caractères écrit sans le `\0` terminal(si réussite).
```C
FILE *fp = fopen("text.txt", "w");
fprintf(fp, "Hello world! We are in %d\n", 2020);
// Écrit "Hello world! We are in 2020"
// dans le fichier fp
fclose(fp);
```
# Écriture dans un fichier (2/2)
```C
size_t fwrite(const void *ptr, size_t size,
size_t nmemb, FILE *stream)
```
* Écrit `nmemb` éléments de taille `size` octets se trouvant à l'adresse `ptr` dans le fichier `stream`.
* Retourne le nombre d'éléments écrits.
```C
FILE *fp = fopen("doubles.bin", "wb");
double buffer[] = {1.0, 2.0, 3.0, 7.0};
size_t num = fwrite(buffer, sizeof(double), 4, fp);
// écrit 4 double, se trouvant à l'adresse
// buffer dans le fichier fp au format binaire
// retourne 4
fclose(fp);
```
# Les pointeurs de fichiers spéciaux
* Il existe trois `FILE *`{.C} qui existent pour tout programme:
* `stdin`{.C}: l'entrée standard.
* `stdout`{.C}: la sortie standard.
* `stderr`{.C}: l'erreur standard.
* Lors d'un fonctionnement dans le terminal:
* l'entrée standard est le *clavier*
* la sortie et erreur standard sont affichés dans le *terminal*.
* Ainsi on a
```C
fprintf(stdout, "texte\n"); // == printf("texte\n");
int a;
fscanf(stdin, "%d", &a); // == scanf("%d", &a);
```
slides/figs/comm_dec.svg deleted 100644 → 0
+ 0
− 2180
View file @ ac81f962
This diff is collapsed.
slides/figs/comm_normal.svg deleted 100644 → 0
+ 0
− 3158
View file @ ac81f962
This diff is collapsed.
slides/figs/compilation.svg deleted 100644 → 0
+ 0
− 1343
View file @ ac81f962
This diff is collapsed.
slides/figs/compilation_plusieurs.svg deleted 100644 → 0
+ 0
− 1513
View file @ ac81f962
This diff is collapsed.
slides/figs/complex_makefile.svg deleted 100644 → 0
+ 0
− 403
View file @ ac81f962
This diff is collapsed.
slides/figs/double_pointeur.svg deleted 100644 → 0
+ 0
− 1038
View file @ ac81f962
This diff is collapsed.
slides/figs/ex_makefile.svg deleted 100644 → 0
+ 0
− 387
View file @ ac81f962
This diff is collapsed.
slides/figs/ex_makefile_cible.svg deleted 100644 → 0
+ 0
− 498
View file @ ac81f962
This diff is collapsed.
slides/figs/ex_makefile_dep.svg deleted 100644 → 0
+ 0
− 592
View file @ ac81f962
This diff is collapsed.
slides/figs/ex_makefile_regle.svg deleted 100644 → 0
+ 0
− 500
View file @ ac81f962
This diff is collapsed.
slides/figs/git_meme.png deleted 100644 → 0
+ 0
− 0
View file @ ac81f962
slides/figs/git_meme.png

73.8 KiB

slides/figs/memory.svg deleted 100644 → 0
+ 0
− 2428
View file @ ac81f962
This diff is collapsed.
slides/figs/pointer_arithmetics.svg deleted 100644 → 0
+ 0
− 1265
View file @ ac81f962
This diff is collapsed.
slides/figs/pointer_struct.svg deleted 100644 → 0
+ 0
− 454
View file @ ac81f962
This diff is collapsed.
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment