updated base_3

Makefile

@@ -9,6 +9,7 @@ PDFOPTIONS += --template=./default.latex
 PDFOPTIONS += -V theme:metropolis
 PDFOPTIONS += -V themeoptions:numbering=none -V themeoptions:progressbar=foot
 PDFOPTIONS += -V fontsize=smaller
+# PDFOPTIONS += --filter  pandoc-beamer-block
 # PDFOPTIONS += --lua-filter=${FILTERDIR}/tex.lua
 # PDFOPTIONS += --include-in-header=${RESOURCEDIR}/definitions.tex
 # PDFOPTIONS += --include-in-header=${RESOURCEDIR}/beamer.tex

base_3.md

@@ -2,8 +2,183 @@
 % Base III - Inspirés des slides de F. Glück
 % 2 octobre 2019
 
+# Types complexes: `struct`{.C} (1/N)
+
+## Généralités
+
+- Plusieurs variables qu'on aimerait regrouper dans un seul type: `struct`{.C}.
+
+    ```C
+    struct complex { // déclaration
+        double re;
+        double im;
+    };
+
+    struct complex num; // déclaration de num
+    ```
+- Les champs sont accessible avec le sélecteur "`.`{.C}".
+
+    ```C
+    num.re = 1.0;
+    num.im = -2.0;
+    ```
+
+# Types complexes: `struct`{.C} (2/N)
+
+## Simplifications
+
+- `typedef`{.C} permet de définir un nouveau type.
+
+    ```C
+    typedef unsinged int uint;
+    typedef struct complex complex_t;
+    typedef struct _complex {
+        double re, im;
+    } complex_t;
+    ```
+- L'initialisation peut aussi se faire avec
+
+    ```C
+    complex_t num = {1.0, -2.0}; // re = 1.0, im = -2.0
+    complex_t num = {.im = 1.0, .re = -2.0};
+    complex_t num = {.im = 1.0}; // argl! .re non initialisé 
+    complex_t num2 = num; // copie
+    ```
+
+# Types complexes: `struct`{.C} (3/N)
+
+## Pointeurs
+
+- Comme pour tout type, on peut avoir des pointeurs vers un `struct`{.C}.
+- Les champs sont accessible avec le sélecteur `->`{.C}
+
+    ```C
+    complex_t *num; // on crée un pointeur
+    num->re = 1.0;  // seg fault...
+    num->im = -1.0; // mémoire pas allouée.
+    ```
+
+# Allocation dynamique de mémoire (1/N)
+
+- La fonction `malloc`{.C} permet d'allouer dynamiquement (pendant l'exécution du programme) une zone de mémoire contiguë.
+
+    ```C
+    #include <stdio.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}.
+
+# Allocation dynamique de mémoire (2/N)
+
+- Avec l'exemple de tout à l'heure:
+
+    ```C
+    complex_t *num = malloc(sizeof(complex_t));
+    num->re = 1.0;  // maintenant ...
+    num->im = -1.0; // ça marche.
+    ```
+- La zone mémoire **n'est pas** initialisée.
+- La mémoire doit être désallouée explicitement $\Rightarrow$ **fuites mémoires**.
+- Toujours garder un pointeur sur la mémoire allouée sinon **pointeur pendouillant**.
+
+# Allocation dynamique de mémoire (3/N)
+
+- 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);
+    ```
+- Pour 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}.
+
+# Allocation dynamique de mémoire (4/N)
+
+## Tableaux dynamiques
+
+- Pour allouer un espace mémoire de 50 entiers:
+
+    ```C
+    int *p = malloc(50 * sizeof(int));
+    ```
+- Cette espace peut alors être utilisé comme un tableau de 50 entiers:
+
+    ```C
+    for (int i = 0; i < 50; ++i) {
+        p[i] = 0;
+    }
+    ```
+
+## Arithmétique de pointeurs
+
+- Autre façon d'indéxer un tableau
+    
+    ```C
+    int *p = malloc(50 * sizeof(int)); // initialize somehow
+    double a = p[7];
+    double b = *(p + 7); // on avance de 7 "double"
+    p[0] == *p; // rappel, le pointeur est le premier élément
+    ```
+
+# Prototypes de fonctions (1/N)
+
+## 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/N)
+
+- 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/N)
+
+## 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> // libraire dans LD_LIBRARY_PATH
+    #include "chemin/du/prototypes.h"// chemin explicite
+    ```
+
 # Génération d'un exécutable (1/N)
 
+## Un seul fichier source
+
+![Étapes de génération.](figs/compilation.svg){#fig:compilation width=100%}
+
+# Génération d'un exécutable (2/N)
+
+## Un seul fichier source
+
 ```bash
 gcc proc.c -o prog
 ```
@@ -15,7 +190,82 @@ gcc proc.c -o prog
 
 Les différents codes intermédiaires sont effacés.
 
-# Génération d'un exécutable (2/N)
+# Génération d'un exécutable (3/N)
 
-![Étapes de génération.](figs/compilation.svg){#fig:compilation width=100%}
+## Plusieurs fichiers sources
+
+![Étapes de génération, plusieurs fichiers.](figs/compilation_plusieurs.svg){#fig:compilation_plusieurs width=100%}
+
+# Génération d'un exécutable (4/N)
+
+::: 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 (4/N)
+
+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
+    ```