base_3.md

---
title: Base III
date: 2020-09-30
---

# Le C sur stackoverflow

## Le C est-il un langage encore utilisé (ou juste une vieille croûte inutile)?

![](figs/stackoverflow.png)

# Types complexes: `struct`{.C} (1/5)

## 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/5)

## 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/5)

## 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.
    ```

![La représentation mémoire de `complex_t`.](figs/pointer_struct.svg){width=100%}

# Types complexes: `struct`{.C} (4/5)

## Initialisation

- Avec le passage par **référence** on peut modifier un struct *en place*.
- Les champs sont accessible avec le sélecteur `->`{.C}

    ```C
    void complex_init(complex_t *num, 
                      double re, double im) 
    {
        // num a déjà été allouée
        num->re = re;
        num->im = im;
    }
    int main() {
        complex_t num; // on alloue un complexe
        complex_init(&num, 2.0, -1.0); // on l'initialise
    }
    ```

# Types complexes: `struct`{.C} (5/5)

## Initialisation version copie

* On peut allouer un complexe, l'initialiser et le retourner.
* La valeur retournée peut être copiée dans une nouvelle structure.

    ```C
    complex_t complex_create(double re, double im) {
        complex_t num;
        num.re = re;
        num.im = im;
        return num;
    }
    int main() {
        // on crée un complexe et on l'initialise
        // en copiant le complexe créé par complex_create
        // deux allocation et une copie
        complex_t num = complex_create(2.0, -1.0); 
    }
    ```

# Les fonctions (1/2)

## Arguments de fonctions par copie

- Les arguments d'une fonction sont toujours passés **par copie**.
- Les arguments d'une fonction ne peuvent **jamais** être modifiés.

    ```C
    void do_something(complex_t a) { // a: nouvelle variable
        // valeur de a est une copie de x
        // lorsque la fonction est appelée, ici -1
        a.re += 2.0;
        a.im -= 2.0;
    } // a est détruite

    int main() {
        complex_t x;
        do_something(x); // x est passé en argument
        // x sera inchangé
    }
    ```

* Que pourrait-on faire pour modifier `x`{.C}?

# Les fonctions (2/2)

## Arguments de fonctions par référence

- Pour modifier une variable, il faut passer son **adresse mémoire** (sa référence) en argument.
- L'adresse d'une variable, `a`{.C}, est accédée par `&a`{.C}.
- Un **pointeur** vers une variable entière `a` le type, `int *`{.C}.
- `*a`{.C} sert à **déréférencer** le pointeur (accéder la mémoire pointée).

    ```C
    void do_something(complex_t *a) {
        // a: un nouveau pointeur
        // valeur de a est une copie de du pointeur
        // passé en argument, mais
        // les données pointées sont les données originales
        a->re += 2.0;
        a->im -= 2.0;
    } // le pointeur a est détruit, 
      // *a est toujours là et a été modifié
    ```

# Prototypes de fonctions (1/3)

## 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> // libraire dans LD_LIBRARY_PATH
    #include "chemin/du/prototypes.h"// chemin 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)

## Un seul fichier source

```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.

# 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)

::: 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)

## 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
    ```
- Les inclusions multiples peuvent poser problème: définitions multiples. Les headers commencent par:

    ```C
    #ifndef _VAR_
    #define _VAR_
    /*
    commentaires
    */
    #endif
    ```

# Les tableaux (1/2)

## Généralités

- `C` offre uniquement des tableaux statiques
    - Un tableau est un "bloc" de mémoire contiguë associé à un nom
        - taille fixe déterminée à la déclaration du tableau
        - la taille ne peut pas être changée.
    - Pas d’assignation de tableaux.
    - Un tableau déclaré dans une fonction ou un bloc est détruit à la sortie de celle/celui-ci
        - $\Rightarrow$ Un tableau local à une fonction ne doit **jamais être retourné** (aussi valable pour toute variable locale)!
- Les éléments d’un tableau sont accédés avec `[i]`{.C} où `i`{.C} est l’index de l’élément.
- 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/2)

## Exemple

```C
float tab1[5]; // tableau de floats à 5 éléments
               // ses valeurs sont indéfinies

int tab2[] = {1, 2, 3}; // tableau de 3 entiers, 
                        // taille inférée

int val = tab2[1]; // val vaut 2 à présent

int w = tab1[5]; // index hors des limites du tableau
                 // comportement indéfini!
                 // pas d'erreur du compilateur
```

# La ligne de commande (1/4)

## 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ère**.
- Peu pratique si on veut manipuler des valeurs numériques.
- Fonctions pour faire des conversions:

    ```C
    int atoi(const char *nptr);
    long atol(const char *nptr);
    long long atoll(const char *nptr);
    double atof(const char *nptr);
    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;
    }

    char *name = argv[1];
    int age = atoi(argv[2]);

    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.
```