Cours 2

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

# Programmation procédurale- CM 2
## Inès de Courchelle
## Les Entrées/Sorties

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

---
layout: false
# Lets go
## Objectifs
- Lire le manuel C proposé dans le terminal
- Comprendre le formatage des E/S
- Lever une erreur sur une entrée clavier
- Connaître les opérateurs algébriques et booléens en C

---
# TODAY
## Plan
1. Le manuel
2. E/S formatées
3. Les opérateurs : algébriques et logiques
4. Lancer des commandes unix depuis un programme C

---
# TODAY
## Plan
1. .under[Le manuel]
2. E/S formatées
3. Les opérateurs : algébriques et logiques
4. Lancer des commandes unix depuis un programme C

---
# Le manuel
## Afficher dans le terminal
#### Comment ?
Dans un terminal, il suffit de taper :
```bash
man 3 <nom de la commande>
```

#### Pourquoi ?
- Pour savoir comment fonctionne une commande
- Quelle(s) bibliothèque(s) une fonction a besoin pour s'exécuter
- Parce que !

---
# Le manuel
## Les sections
- **NAME** : toutes les fonctions qui correspondent à la page de manuel
- **SYNOPSIS** : le prototype des fonctions, les librairies à inclure, voire même les liens à utiliser
- **DESCRIPTION** : description des fonctions
- **ERRORS** : quelles erreurs sont traitées
- **RETURN VALUE** : ce que retourne la fonction ainsi que la signification éventuelle
- **SEE ALSO** : d’autres commandes similaires
- **BUGS** : les bugs connus

---
# Le manuel
## VAR
<center>
<video src="videos/man3.mp4" width=400 controls poster="vignette.jpg"></a>
</video>
</center>

---
# TODAY
## Plan
1. Le manuel
2. .under[E/S formatées]
3. Les opérateurs : algébriques et logiques
4. Lancer des commandes unix depuis un programme C

---
# E/S
## De manière générale en informatique
#### Périphériques d'entrée
clavier, souris, caméra, scanneur, ...

#### Périphériques de sortie
écran, imprimante, haut parleur, ...

---
# E/S
## Dans un programme
#### Entrée
Clavier

#### Sortie
Écran

---
# E/S
## Exemple
```c
#include <stdio.h>
#include <stdlib.h>

int main(){
    printf("Bonjour, quel age as tu ? \n");
    scanf("%d",&age);
    return 0;
}
```

---
# E/S
## 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                 |

---
# E/S
## 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
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

---
# E/S
## 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
printf("Combien vaut PI ? \n");
scanf("%f", &pi);
printf("PI est égal à %f \n",pi);
```

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

---
# E/S
## 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
printf("Quel est la première lettre de votre prénom ? \n");
scanf("%c", &initial);
printf("La première lettre est %c \n",initial);
```

---
# E/S
## 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
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

---
# E/S
## Les booleens
- Il n'y a pas de type booléens en C
- On utilise un ENTIER

| **   | ** |
|------|----|
| VRAI | 1  |
| FAUX | 0  |

---
# E/S
## Afficher une approximation
- %.2f .arrow[] 2 chiffres après la virgule
- %.3f .arrow[] 3 chiffres après la virgule
- %.4f .arrow[] 4 chiffres après la virgule
- %.5f .arrow[] 5 chiffres après la virgule
- ...

---
# E/S
## Exemple

```c
#include <stdlib.h>

int main() {
    double a,b;
    double res;

printf("Entrez 2 réels : \n");
    scanf("%lf",&a);
    scanf("%lf",&b);

res = a/b;

printf("res = %lf \n",res);

return 0;

}
```

---
# E/S
## Exemple
<center>
<video src="videos/appro.mp4" width="200"  controls poster="vignette.jpg"> </video>
</center>

---
# E/S
## Problématique
Que se passe t-il si la lecture clavier de l'utilisateur est un entier et que l'on rentre une chaîne de caractères ?

## 2 étapes
1. vider le buffer
2. vérifier la valeur de retour du scanf

---
# E/S
## Problématique
Que se passe t-il si la lecture clavier de l'utilisateur est un entier et que l'on rentre une chaîne de caractères ?

## 2 étapes
1. .under[vider le buffer]
2. vérifier la valeur de retour du scanf

---
# E/S
## Vider le buffer
Supprimer tous les caractères encore présents dans le flux d’entrée standard (stdin), généralement laissés après une lecture au clavier (comme avec scanf).

## Le buffer
Zone mémoire temporaire où sont stockées les frappes clavier avant d’être lues par ton programme

## La procédure
```c
/* Auteur : Peio */
/* Date :  19/11/20 */
/* Résumé :  procédure qui permet de vider le buffer d'un scanf */
/* Entrée(s) :  aucune */
/* Sortie(s) :  aucune */
void emptyBuffer() {
  char c;
  while (((c = getchar()) != '\n') && (c != EOF));
}
```
---
# E/S
## Vider le buffer
#### \n
La procédure permet de vider le flux d'entrée standard car lorsque l'utilisateur appuie sur entrée cela génere le caractère **\n** et parfois il apparaît dans le buffer (flux d'entrée standard) et générer des mauvaises lectures lorsque l'on enchaîne les scanf.

#### EOF (End Of File)
Dans notre contexte, c'est la fin du flux d'entrée standard (buffer)

```c
/* Auteur : Peio */
/* Date :  19/11/20 */
/* Résumé :  procédure qui permet de vider le buffer d'un scanf */
/* Entrée(s) :  aucune */
/* Sortie(s) :  aucune */
void emptyBuffer() {
  char c;
  while (((c = getchar()) != '\n') && (c != EOF));
}
```

---
# E/S
## Problématique
Que se passe t-il si la lecture clavier de l'utilisateur est un entier et que l'on rentre une chaîne de caractères ?

## 2 étapes
1. .under[vider le buffer]
2. vérifier la valeur de retour du scanf

---
# E/S
## 1. vider le buffer

---
# E/S
## Problématique
Que se passe t-il si la lecture clavier de l'utilisateur est un entier et que l'on rentre une chaîne de caractères ?

## 2 étapes
1. vider le buffer
2. .under[vérifier la valeur de retour du scanf]

---
# E/S
## Vérifier la valeur de retour du scanf
Récupérer la valeur de retour du scanf et si cette valeur de retour est égale à 0 alors il y a une erreur de saisie.

## Scanf
<img src="img/fonctionScanf.png" width=600>
Dans notre cas scanf est une fonction C qui prend 2 paramètres (*"%d"*, et *&nb*), et renvoi 0 s'il y a une erreur de typage sinon elle renvoie 1.

---
# E/S
## VAR
<center>
<video src="videos/retourScanf.mp4" width="200"  controls poster="vignette.jpg"> </video>
</center>

---
# TODAY
## Plan
1. Le manuel
2. E/S formatées
3. .under[Les opérateurs : algébriques et logiques]
4. Lancer des commandes unix depuis un programme C

---
# Les opérateurs
## Algébrique
| **             | Opérateurs |
|----------------|------------|
| Addition       | +          |
| Soustraction   | -          |
| Multiplication | *          |
| Division       | /          |
| Modulo         | %          |

---
# Les opérateurs
## Comparaison
| **                | Opérateurs |
|-------------------|------------|
| Égalité           | ==         |
| Inférieur         | <          |
| Supérieur         | >          |
| Inférieur ou égal | <=         |
| Supérieur ou égal | >=         |
| Différent         | !=         |

---
# Les opérateurs
## Logique
<table>
  <tr><th></th><th>Opérateurs</th></tr>
  <tr><td><b>NON</b></td><td>!</td></tr>
  <tr><td><b>ET</b></td><td>&&</td></tr>
  <tr><td><b>OU</b></td><td>||</td></tr>
</table>

---
# Les opérateurs
## Exemple
L'opérateur modulo représenté par **%** renvoie le reste de la division entière.
```c
#include <stdio.h>

int main() {
    int nombre;

printf("Entrez un nombre entier : ");
    scanf("%d", &nombre);

if (!(nombre % 2)) {
        printf("Le nombre %d est pair \n", nombre);
    } else {
        printf("Le nombre %d est impair \n", nombre);
    }

return 0;
}
```
---
# Les opérateurs
## VAR

---
# TODAY
## Plan
1. Le manuel
2. E/S formatées
3. Les opérateurs : algébriques et logiques
4. .under[Lancer des commandes unix depuis un programme C]

---
# Commandes unix en C
## c-à-d
Lancer des commandes unix depuis un programme C

## Pourquoi ?
- .under[Automatiser des tâches système :] un programme C peut exécuter automatiquement plusieurs commandes Unix sans intervention humaine.
- .under[Interaction avec le système d’exploitation :] pour gérer des fichiers, des processus, des permissions, etc.
- .under[Débogage ou supervision :] exécuter des commandes pour surveiller l’état du système ou collecter des informations.
- .under[Scripts hybrides :] remplacer ou compléter un script shell par un programme plus complexe en C.

---
# Commandes unix en C
## Comment ?
Via l'instruction **sytem** disponible dans la bibliothéque **stdlib.h**

## Exemple 1 : afficher les droits

```c
#include <stdlib.h>

int main() {
    system("ls -l");
    return 0;
}
```

---
# Commandes unix en c
## Exemple 2 : effacer le terminal au bout de 5 secondes
<center>
<video src="videos/sleep.mp4" width="200"  controls poster="vignette.jpg"> </video>
</center>

---
# Commandes unix en c
## Exemple 3 : afficher un fichier texte
<center>
<video src="videos/afficherTexte.mp4" width="200"  controls poster="vignette.jpg"> </video>
</center>

---
# Commandes unix en c
## Exemple ... : Toutes les commandes unix
<center>
<video src="videos/completeUnix.mp4" width="200"  controls poster="vignette.jpg"> </video>
</center>

---
# Conclusion
## Les objectifs
- Lire le manuel C proposé dans le terminal
- Comprendre le formatage des E/S
- Lever une erreur sur une entrée clavier
- Connaître les opérateurs algébriques et booléens en C