Cours 3

name: inverse
layout: true
class: center, middle, inverse
---

# Programmation procédurale- CM3
## Inès de Courchelle
## Variables et fonctions

![image](../img/CY-tech.png)

---
layout: false
# Lets go
## Objectifs
- Manipuler des fonctions/procédures en C
- Connaître la différences entre une variable globale ou locale
- Se servir du mot clé STATIC
- Réaliser des tests de fonctions/procédures
- Utiliser la sortie d'erreur
- Mettre en place de la compilation conditionnelle

---
# TODAY
## Plan
1. Les fonctions et procédures en C
2. Les différentes catégories de variables
3. Les tests de fonctions
4. La sortie d'erreur

---
# TODAY
## Plan
1. .under[Les fonctions et procédures en C]
2. Les différentes catégories de variables
3. Les tests de fonctions
4. La sortie d'erreur

---
# Les fonctions
## Définitions
Une FONCTION est une suite d'instructions qui prend une liste de paramètres en entrée et produit (retourne) un résultat en sortie au code appelant cette fonction.

## Objectifs
- factoriser des instructions
- automatiser des procesus
- diviser un algorithme

---
# Les fonctions
## Algo VS C
#### En algo
```c
FONCTION addition(a,b: entier) : entier
DEBUT
    retourner (a+b)
FIN
```
#### En C
```c
int addition(int a,int b){
    return (a+b);
}

```

---
# Les fonctions
## Explications
<img src="img/laFonction.svg" width=500>

---
# Les fonctions
## Explications
<img src="img/masqueFonction.svg" width=600>

---
# Les fonctions
## VAR

<center>
<video src="videos/lesFonctions.mp4" width="400" height="300" controls poster="vignette.jpg">
Cette vidéo ne peut être affichée sur votre navigateur Internet. Une version est disponible en téléchargement sous <a href="URL">adresse du lien </a> .
</video>
</center>

---
# Les fonctions
## De manières générales
```c
typeRetourné nomFonction(paramètres) {
    ...
    return ...
}
```

---
# Les procédures
## Définitions
- Une **PROCÉDURE** est ensemble d’instructions, prenant entrée des paramètres **MAIS** qui ne retourne rien
- Souvent utilisées pour réaliser des affichages ou réaliser des traitements

## Objectifs
- factoriser une liste d'instructions
- automatiser des procesus
- diviser un algorithme

---
# Les procédures
## Algo VS C
#### En Algo
```
PROCEDURE bonjour(nom, prenom : chaine de caractères)
DEBUT
    ECRIRE("Bonjour " +prenom + " " + nom + " " + "ça va ?")
FIN
```

#### En C
```c
void bonjour (char nom[100],char prenom[100]){
    printf("Bonjour %s %s ça va ? \n",nom,prenom);
}
```

---
# Les procédures
## Algo VS C
<img src="img/laProcédure.svg" width=600>

---
# Les procédures
## Algo VS C
<img src="img/masqueProcedure.svg" width=800>

---
# Les procédures
## Ne pas oublier !
<img src="img/tailleChaine.svg" width=800>

---
# Les procédures
## VAR

<center>
<video src="videos/lesProcedures.mp4" width="400" height="300" controls poster="vignette.jpg">
Cette vidéo ne peut être affichée sur votre navigateur Internet. Une version est disponible en téléchargement sous <a href="URL">adresse du lien </a> .
</video>
</center>

---
# Les procédures
## De manières générales
```c
void nomProcédure(paramètres) {
    ...
}
```

---
# TODAY
## Plan
1. Les fonctions et procédures en C
2. .under[Les différentes catégories de variables]
3. Les tests de fonctions
4. La sortie d'erreur

---
# Les variables
## (Rappel) Les types
| Catégorie                  | Type          | Taille          | Exemple                      | Description                        |
| -------------------------- | ------------- | --------------- | ---------------------------- | ---------------------------------- |
| Entier signé               | `int`         | 4 octets        | `int x = 5;`                 | Nombre entier (positif ou négatif) |
| Entier court               | `short`       | 2 octets        | `short s = -3;`              | Entier plus petit                  |
| Entier long                | `long`        | 4 ou 8 octets   | `long l = 123456;`           | Entier plus grand                  |
| Entier très long           | `long long`   | 8 octets        | `long long ll = 9999999999;` | Très grand entier                  |
| Caractère                  | `char`        | 1 octet         | `char c = 'A';`              | Un seul caractère ASCII            |
| Réel simple précision      | `float`       | 4 octets        | `float f = 3.14;`            | Nombre à virgule flottante         |
| Réel double précision      | `double`      | 8 octets        | `double d = 3.141592;`       | Plus précis que `float`            |
| Réel très grande précision | `long double` | 12 ou 16 octets | `long double ld = 1.23e50;`  | Encore plus précis                 |

---
# (Rappel) Les types
## Lire et écrire un entier
%d .arrow[] caractère par lequel on représente un entier dans une chaîne de format (spécificateur de format)

#### Exemple
```c
int age;
printf("Quel est votre age ? \n");
scanf("%d", &age);
printf("Votre age est %d ans \n",age);
```

.underR[Attention] NE PAS OUBLIER LE & pour le scanf

---
# (Rappel) Les types
## Lire et écrire un réel
%f .arrow[] caractère par lequel on représente un réel dans une chaîne de format (spécificateur de format)

#### Exemple
```c
float pi;
printf("Combien vaut PI ? \n");
scanf("%f", &pi);
printf("PI est égal à %f \n",pi);
```

.underR[Attention] NE PAS OUBLIER LE & pour le scanf

---
# (Rappel) Les types
## Lire et écrire un caractère
%c .arrow[] caractère par lequel on représente un caractère dans une chaîne de format (spécificateur de format)

#### Exemple
```c
char initial;
printf("Quel est la première lettre de votre prénom ? \n");
scanf("%c", &initial);
printf("La première lettre est %c \n",initial);
```

---
# (Rappel) Les types
## Lire et écrire une chaîne de caractères
%s .arrow[] caractère par lequel on représente une chaîne de caractères dans une chaîne de format (spécificateur de format)

#### Exemple
```c
char prenom[100];
printf("Quel est votre prénom ? \n");
scanf("%s", prenom);
printf("La première lettre est %s \n",prenom);
```

.underR[Attention]

- Il n'y a PAS de & pour le scanf
- Il faut définir le nombre max de caractères entre crochet que va contenir la variable !

---
# Les catégories
## Durée de vie
- Une variable a la durée de vie sur son bloc
- Cela correspond à la période pendant laquelle la variable existe en mémoire c-à-d le moment où elle est créée et celui où elle est détruite

## La liste
- Variable locale
- Variable statique
- Variable globale
- Variable dynamique

---
# Les qualificatifs
## La liste
- .under[const :] variable ne doit pas être modifiable généralement pour les paramètres de méthodes en lecture seul
- .under[volatile :]  variable peut être modifiée par d’autres programmes
  - variable partagée par d’autres programme
  - zone de mémoire partagée
  - ...
- .under[register :] variable doit être placée dans un registre processeur (variable utilisée fréquement)
- .under[extern :] variable définie ailleurs
- .under.under[static :] permet d’avoir une variable avec une durée de vie de la durée du programme

---
# Variable locale
## Définition
- Ce sont des variables déclarées à l'intérieur d'une fonction ou procédure.
- Durée de vie : de leur déclaration jusqu'à la fin de la fonction ou procédure
- Destruction : à la fin de l’exécution de la fonction ou procédyre
- Zone mémoire : pile (stack).
- Elles sont recréées à chaque appel de la fonction

## Exemple
.pull-left[
#### Une procédure
```c
void maSuperProcédure() {
    int x = 10;
}
```
]
.pull-right[
#### Une fonction
```c
int maSuperFonction() {
    int x = 10;
    return (4+2);
}
```
]
---
# Variable statique
## Définition
- Déclarées avec le mot-clé static
- Durée de vie : du début du programme jusqu’à sa fin
- Portée : limitée au bloc ou fichier où elle est déclarée.
- Particularité : La variable conserve sa valeur entre les appels de la fonction.

## Exemple
```c
void maSuperProcedure() {
    static int compteur = 0;
    compteur++;
    printf("Le compteur %d \n",compteur);
}
```

---
# Variable statique
## Exemple

<center>
<video src="videos/static.mp4" width="400" height="300" controls poster="vignette.jpg">
Cette vidéo ne peut être affichée sur votre navigateur Internet. Une version est disponible en téléchargement sous <a href="URL">adresse du lien </a> .
</video>
</center>

---
# Variable globale
## Définition
- Elle est déclarée en dehors de toute fonction/procédure/programme.
- Durée de vie : du début à la fin du programme.
- Portée : tout le fichier (ou plusieurs fichiers si extern est utilisé).

## Exemple
```c
#include <stdio.h>
#include <stdlib.h>

int global = 5;

void ajouter(int a){
    global+=a; //global = global + a
}

int main() {
    printf("la variable globale %d \n",global);
    ajouter(4);
    printf("la variable globale %d \n",global);
    return 0;
}
```

---
# Variable globale
## VAR

<center>
<video src="videos/globale.mp4" width="400" height="300" controls poster="vignette.jpg">
Cette vidéo ne peut être affichée sur votre navigateur Internet. Une version est disponible en téléchargement sous <a href="URL">adresse du lien </a> .
</video>
</center>

---
# Variable dynamique
## Définition
- Elle est créée manuellement à l’aide de malloc(), calloc(), realloc().
- Portée : limitée au bloc ou fichier où elle est déclarée.
- C'est le programmeur qui contrôle sa destruction mémoire

## Exemple
```c
int* nom = malloc(sizeof(int)*100);
```

.underR[On va faire un CM dessus !]

---
# Les variables
## Récapitulatifs

| Type de variable     | Début de vie        | Fin de vie       | Mot-clé associé          |
|----------------------|---------------------|------------------|--------------------------|
| Locale (automatique) | Entrée dans le bloc | Sortie du bloc   | (aucun)                  |
| Statique             | Début du programme  | Fin du programme | static                   |
| Globale              | Début du programme  | Fin du programme | (aucun ou extern)        |
| Dynamique            | malloc()            | free()           | (fonctions d’allocation) |

---
# TODAY
## Plan
1. Les fonctions et procédures en C
2. Les différentes catégories de variables
3. .under[Les tests de fonctions]
4. La sortie d'erreur

---
# Les directives préprocesseurs
## Définition
Directive exécutée lors de la première phase de la compilation

## La directive \#define
#### Objectifs
- Des constantes symboliques
- Des macros avec paramètres
- Remplacer une ”expression” par un symbole dans le code
- Permet de clarifier le code

---
# Les directives préprocesseurs
## La directive \#define
#### Utilisation
- Utiliser des majuscules
- Éviter de mettre un ; à la fin d’un define

#### Définition de constantes symboliques
```c
#define NB_LIGNES 10
#define NB_COLONNES 33
#define TAILLE_MATRICE NB_LIGNES * NB_COLONNES
```

---
# La directive \#define
## Des macros
Une macro avec paramètres se définit de la manière suivante :
```c
#define nom(param1,param2) contenu de la macro
```
## Exemple
```c
#define MAX(a,b) (a > b ? a : b)
```
Le processeur remplacera dans la suite du code toutes les occurences du type
```c
MAX(x,y)
```

---
# La directive \#define
## Des macros
```c
#define MAX(a,b) (a > b ? a : b)
```
- Elle prend 2 paramètres a et b .arrow[] la signature de la macro : MAX(a,b)
- Elle renvoie a ou b .arrow[] le corps de la macro (a > b ? a : b)
 - si a > b alors je renvoie a
 - si a < b alors je renvoi b

---
# La directive \#define
## le code
```c
#include<stdlib.h>
#include<stdio.h>
#define MAX(a,b) (a > b ? a : b)

int main(){
  int x,y;

printf("veuillez saisir x :\n");
  scanf("%d",&x);

printf("veuillez saisir y :\n");
  scanf("%d",&y);

printf("le plus grand entre x= %d et y=%d est %d \n",x,y,MAX(x,y));
  return 0;
}

```

---
# La directive \#define
## VAR
<center>
<video src="videos/macro.mp4" width="400" height="300" controls poster="vignette.jpg">
Cette vidéo ne peut être affichée sur votre navigateur Internet. Une version est disponible en téléchargement sous <a href="URL">adresse du lien </a> .
</video>
</center>

---
# La directive \#define
## Tester une fonction
```c
#include<stdlib.h>
#include<stdio.h>
#define ERREUR_SAISIE -1

int main(){
  int x, valeurRetourX;

printf("veuillez saisir un entier :\n");
  valeurRetourX=scanf("%d",&x);
  if (!valeurRetourX){
    exit(ERREUR_SAISIE);
  }

printf("L'utilisateur a écrit %d \n",x);

return 0;
}
```
---
# La directive \#define
## VAR
<center>
<video src="videos/erreurSaisie.mp4" width="400" height="300" controls poster="vignette.jpg">
Cette vidéo ne peut être affichée sur votre navigateur Internet. Une version est disponible en téléchargement sous <a href="URL">adresse du lien </a> .
</video>
</center>

---
# Assertion
## Définition
Vérification effectuée pendant l’exécution du programme pour s’assurer qu’une condition supposée vraie l’est réellement.

## Objectifs
- Détecter des erreurs logiques ou des situations inattendues pendant le développement
- Faciliter le débogage en signalant immédiatement quand une hypothèse du programme n'est pas respectée
- Documenter les préconditions : on exprime clairement les conditions supposées vraies à un point précis du code.

## Utilisation
- En C, elle est fournie par la macro assert() définie dans le fichier d’en-tête <assert.h>.
 - Si la condition est vraie, Alors le programme continue normalement.
 - Si la condition est fausse, Alors le programme s’arrête et affiche un message indiquant la condition échouée, le nom du fichier et le numéro de ligne.
 - Peut être enlevé en utilisant -DNDEBUG lors de la compilation

---
# Assertion
## Exemple
```c
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>

int divise(int a, int b) {
    assert(b != 0);
    return a / b;
}

int main(){
  int x, y;

printf("veuillez saisir un entier x :\n");
    scanf("%d",&x);

printf("veuillez saisir un entier x :\n");
    scanf("%d",&y);

printf("la division de %d par %d donne %d \n",x,y,divise(a,b));

return 0;
}
```
---
# Assertion
## VAR
<center>
<video src="videos/assert.mp4" width="400" height="300" controls poster="vignette.jpg">
Cette vidéo ne peut être affichée sur votre navigateur Internet. Une version est disponible en téléchargement sous <a href="URL">adresse du lien </a> .
</video>
</center>

---
# La compilation conditionnelle
## Objectifs
- Incorporer ou d'exclure des parties du code source dans le texte qui sera généré par le préprocesseur
- Adapter le programme au matériel ou à l'environnement sur lequel il s'exécute
- Introduire dans le programme des instructions de débogage

---
# La compilation conditionnelle
## Objectifs
- Incorporer ou d'exclure des parties du code source dans le texte qui sera généré par le préprocesseur
- Adapter le programme au matériel ou à l'environnement sur lequel il s'exécute
- .under[Introduire dans le programme des instructions de débogage]

---
# La compilation conditionnelle
## Exemple
```c
#include <stdlib.h>
#include <stdio.h>

int main(){
    int x, y;
    printf("veuillez saisir un entier x :\n");
    scanf("%d",&x);

printf("veuillez saisir un entier x :\n");
    scanf("%d",&y);

#ifdef DEBUG
        printf("x : %d \n",x);
        printf("y : %d \n",y);
    #endif

return 0;
}
```

## La compilation
```shell
gcc -Wall -DDEBUG monProgramme.c -o test
```

---
# La compilation conditionnelle
## VAR
<center>
<video src="videos/conditionnelle.mp4" width="400" height="300" controls poster="vignette.jpg">
Cette vidéo ne peut être affichée sur votre navigateur Internet. Une version est disponible en téléchargement sous <a href="URL">adresse du lien </a> .
</video>
</center>

---
# Les sorties d'erreurs
## Objectifs
- Besoin de détecter les erreurs possibles
- Indiquer ce qui ne va pas
- Donner des messages clairs !
- Utiliser le bon canal de communication

## Les instructions
- fprintf
- stderr

---
# fprintf
## Définition
- une fonction de la bibliothèque standard du langage C (<stdio.h>).
- permet d’écrire du texte formaté (comme printf) mais vers un flux spécifique — par exemple un fichier ou la sortie d’erreur standard (stderr).

## Objectifs
- Afficher des messages formatés vers un flux autre que la sortie standard.
- Signaler des erreurs ou des avertissements sur la sortie d’erreur standard (stderr).
- Séparer les flux d’information :
  - stdout → pour les résultats normaux du programme
  - stderr → pour les messages d’erreur ou de diagnostic

## Unix
- entrée standard : stdin (scanf)
- sortie standard : stdout (printf)
- sortie d’erreur standard : stderr (fprintf)

---
# fprintf
## Exemple
```c
#include <stdio.h>
#include <string.h>

int main(){
 int x,valeurRetourX;
 printf("veuillez saisir un entier :\n");
 valeurRetourX=scanf("%d",&x);
 if (!valeurRetourX){
 fprintf(stderr,"Mauvaise saisie \n");
 }
 return 0;
}
```
---
# fprintf
## VAR
<center>
<video src="videos/fprintf.mp4" width="400" height="300" controls poster="vignette.jpg">
Cette vidéo ne peut être affichée sur votre navigateur Internet. Une version est disponible en téléchargement sous <a href="URL">adresse du lien </a> .
</video>
</center>

---
# strerror
## Définition
- Fonction qui fait partie de la bibliothèque standard du C (<string.h>).
- Elle permet d’obtenir un message d’erreur lisible en texte à partir d’un code d’erreur système (valeur de la variable globale errno).

## Objectifs
- Traduire les codes d’erreur (comme ceux contenus dans errno) en messages compréhensibles pour l’utilisateur.
- Faciliter le débogage en affichant des messages d’erreur explicites.
- Améliorer la lisibilité des messages d’erreur, au lieu d’afficher seulement un code numérique.

## Utilisation
```c
fprintf(stderr, "Mauvaise saisie %s \n", strerror(errno));
```

---
# Conclusion
## Les objectifs
- Manipuler des fonctions/procédures en C
- Connaître la différences entre une variable globale ou locale
- Se servir du mot clé STATIC
- Réaliser des tests de fonctions/procédures
- Utiliser la sortie d'erreur
- Mettre en place de la compilation conditionnelle

## Mise en garde
- Tous les paramètres d’une fonction devraient être testés, sauf si la fonction admet un domaine de définition infini.
- Deux cas possibles :
  - Valeur en dehors de la plage d’utilisation mais acceptable:  Utiliser un test et afficher un message d’avertissement sur la sortie d’erreur standard, à l’aide de fprintf(stderr, ...) et strerror() si nécessaire.
  - Valeur inacceptable : Utiliser exit() pour quitter le programme proprement.
- Les valeurs de retour des fonctions doivent être testées, sauf si l’on est absolument certain qu’il n’y aura jamais d’erreur.