Cours 6

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

---
# Inès de Courchelle
## Informatique 1
## Le C avancé

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

---
layout: false

# Aujourd'hui
## Objectifs
- Gérer les chaînes de caractères
- Vérifier les saisies de l'utilisateur
- Résoudre des problèmes mathématiques
- Automatiser les traitements dans le terminal
- Visualiser une chaîne de caractères

---
# TODAY
## Plan
1. .under[Rappel : Algorithme vs programmation]
2. E/S : La vérification des saisies
3. Les chaînes de caractères en C
4. La bibliothéques Math en C
5. Les commandes unix en C

---
# Algorithmes
## Définition 1
.otro-blockquote[
Un algorithme est la description d'une suite d'étapes permettant d'obtenir un résultat à partir d'éléments fournis en entrée.
]

## Écrire un algo
#### C'est quoi ?
- Une recette de cuisine
 Une suite d'instructions pour aller quelque part
- Des consignes de sécurité

---
# Écrire un algo
## Des Instructions
- Un programme impératif est une suite finie d'instructions comprisent entre le début et la fin
- L'instruction de base est l'écriture (sortie, affichage ...) d'information dans le terminal
- Exemple de programme complet : HELLO WORLD

```
PROGRAMME Bonjour
DEBUT
    ECRIRE("bonjour tout le monde")
FIN
```

---
# Écrire un algo
## Variable
- C'est un élément du programme qui sert à stocker une valeur
- Elle est définie par un nom et un type
- Syntaxe :
```
nomVariable : type
```

## Type
- Ensemble de valeurs sur lesquelles on peut appliquer des opérateurs
- Exemple : entier, réel, booléen, chaîne, caractère ...

---
# Écrire un algo
## Déclaration
```
VARIABLES :
 i,j : entiers
 x,y : réels
 estTrouvé : booleen
 reponse : chaine de caractères
```

## Affectation
- Mettre une valeur dans une variable en cohérence avec son type
- La première affectation de valeur à une variable est appelée initialisation
- On la représente par une flèche

#### Exemple
```
i ← 4
reponse ← "Bonjour"
```
.underR[Attention] : Avant d'affecter une valeur il ne faut pas oublier de déclarer la variable

---
# Écrire un algo
## Exemple complet
```
PROGRAMME Football
VARIABLES :
 numero : entier
DEBUT
 FAIRE
 ECRIRE("Quel est votre numero preferé au foot ? ")
 LIRE(numero)
 TANT QUE (numero < 0 OU numero > 12)

SI (numero > 6) ALORS
        ECRIRE("Tu joues plutôt en attaque")
    SINON
        ECRIRE("Tu joues plus en défense ")
    FIN SI
FIN
```

---
# Écrire un algo
## VAR

---
# Algo. vs Prog.
## Définition
#### Algorithme
- Conception de solution pour résoudre un problème donnée
- Succession d’étape pour résoudre ce problème
- Le problème n’est pas forcement mathématique ou informatique

#### Programmation
- Dire à un ordinateur ce qu'il doit faire
- Écrire les instructions dans un langage compréhensible par la machine (C, python, PHP, pascal, ADA, ...)
- Utiliser les concepts de l’algorithmie pour concevoir les programmes.

---
# Algo. vs Prog
## Exemple
.pull-left[
```c
PROGRAMME PGCD
VARIABLES
 a,b,temp: entier
DEBUT
 REPETER
 ECRIRE("Entrez deux entiers (attention a doit être supérieur à b")
 LIRE(a)
 LIRE(b)
 TANT QUE(a<b)

TANT QUE (b ≠ 0) FAIRE
        temp ← b
        b ← a mod b
        a ← temp
    FIN TANT QUE

ECRIRE ("Le resultat est " + a)
FIN

```
]

.pull-right[
```c
#include <stdio.h>
#include <stdlib.h>

int main(){
	int a,b,temp;

do{
		printf("entrez deux entiers (attention a doit être supérieur à b) \n");
		scanf("%d",&a);
		scanf("%d",&b);
	}while(a<b);

while(b!=0){
		temp = b;
		b = a % b;
		a = temp;
	}
	printf("le resultat est %d \n",a);
    return 0;
}
```
]

---
# Algo. vs Prog
## VAR

---
# Le langage C
## La base
- Le code source (compréhensible par un humain) est enregistré dans un fichier .c ;
- C’est un langage compilé (vs interprété) ;
- Compilation :
```shell
gcc -Wall monCode.c -o monExecutable
```
- Exécution :
```shell
./monExecutable
```

---
# Le langage C
## Programme minimum
```c
#include <stdio.h>
int main(){
 printf("Hello world \n");
 return 0;
}
```

---
# Le langage C
## VAR
<center>
<video src="videos/hw.mp4" width="400" height="300" controls poster="vignette.jpg"></video>
</center>

---
# Le langage C
## Déclaration
.pull-left[
#### En algo
```
VARIABLES :
 i,j : entiers
 x,y : réels
```
]
.pull-right[
#### En C
```c
int i,j:
float x,y;
```
]

## Affectation
.pull-left[
#### En algo
```
i ← 4
x ← 4.2
```
]
.pull-right[
#### En C
```c
i = 4;
x = 4.2;
```
]

.underR[Attention] : Avant d'affecter une valeur il ne faut pas oublier de déclarer la variable

---
# Le langage C
## Les boucles
.pull-left[
```c
TANT QUE (expr) faire
...
FIN TANT QUE
```
]
.pull-right[
```c
While (expr) {
}
```
]

.pull-left[
```c
RÉPETER
...
TANT QUE (expr)
```
]
.pull-right[
```c
do {
...
} while (expr);
```
]

.pull-left[
```c
POUR i ALLANT DE debut À fin faire
...
FIN POUR
```
]
.pull-right[
```c
for (int i=0; i<n; i++) {
...
}
```
]

---
# Le langage C
## Les conditions
.pull-left[
```c
SI (...) alors
    ...
FIN SI
```
]
.pull-right[
```c
if (...) {
    ...
}
```
]

.pull-left[
```c
SI(...) alors
    ...
SINON
    ...
FIN SI
```
]
.pull-right[
```c
if (...) {
    ...
}
else {
    ...
}
```
]
---
# Le langage C
## Les types basiques
- entier : int
- réel : float, double
- caractère : char

## Extension de types
- Taille : short, long (uniquement pour les int et double)
- Signe : unsigned, signed par défaut (uniquement pour les char, int, float)

---
# Le Langage C
## Exemple

.pull-left[
#### En algo
```
PROGRAMME Football
VARIABLES :
 numero : entier
DEBUT
 FAIRE
 ECRIRE("Quel est votre numero preferé au foot ? ")
 LIRE(numero)
 TANT QUE (numero < 0 OU numero > 12)

SI (numero > 6) ALORS
        ECRIRE("Tu joues plutôt en attaque")
    SINON
        ECRIRE("Tu joues plus en défense ")
    FIN SI
FIN
```
]

.pull-right[
#### En C
```
#include <stdio.h>
#include <stdlib.h>

int main(){
 int numero;
 do {
 printf("Quel est votre numero preferé au foot ? \n");
 scanf("%d",&numero);
 }while((numero >12) || (numero < 1));

if (numero > 6) {
    printf("Tu joues plutôt en attaque \n");
  }
  else {
    printf("Tu joues plus en défense \n");
  }
  return 0;
}
```

]

---
# Les types
## Descriptions
| 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                 |

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

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

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

---
# 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 types
## Les booleens
- Il n'y a pas de type booléens en C
- On utilise un ENTIER

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

---
# Les types
## 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
- ...

---
# Les types
## 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;

}
```

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

---
# 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>NON</td><td>!</td></tr>
 <tr><td>ET</td><td>&&</td></tr>
 <tr><td>OU</td><td>||</td></tr>
</table>

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

---
# 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. Rappel : Algorithme vs programmation
2. .under[E/S : La vérification des saisies]
3. Les chaînes de caractères en C
4. La bibliothéques Math en C
5. Les commandes unix en C

---
# 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. Rappel : Algorithme vs programmation
2. E/S : La vérification des saisies
3. .under[Les chaînes de caractères en C]
4. La bibliothéques Math en C
5. Les commandes unix en C

---
# Les chaînes de caractères
## Définition
- C'est un tableau de caractères se terminant par un marqueur de fin de chaı̂ne : ’\0’
- Une case = un caractère

## Exemple
<img src="img/tableauCarExemple.png" width=500>

---
# Les chaînes de caractères
## Déclaration
```c
char nom[20];
```
## Affectation
```c
char nom[20]="alexia";
```

## Affichage
```c
printf("%s \n",nom);
```

---
# Les chaînes de caractères
## Exemple
```c
#include <stdio.h>
#include <stdlib.h>

int main(){
 char nom[100]="alexia";
 int taille = sizeof(nom) / sizeof(nom);
 int i;
 for (int i=0; i< taille;i ++){
 printf("%c ",nom[i]);
 }
 return 0;
}

```

.underR[ça ne marche pas]

---
# Les chaînes de caractères
## Exemple
.pull-left[
```c
#include <stdio.h>
#include <stdlib.h>

int main(){
 char nom[100]="alexia";
 int i;
 i=0;
 while(nom[i]!='\0'){
 printf("%c ",nom[i]);
 i++;
 }
 return 0;
}
```
]
.pull-right[
<img src="img/tabCaracteres.png" width=400>
]

---
# Les chaînes de caractères
## ça marche !
<center>
<video src="videos/exempleTailleChaine.mp4" height="300" width="300" controls poster="vignette.jpg"> </video>
</center>

---
# Les chaînes de caractères
## La biblio string.h

| Fonction            | Rôle                                           |
| ------------------- | ---------------------------------------------- |
| `strlen(s)`         | Calcule la longueur de la chaîne (sans `'\0'`) |
| `strcpy(dest, src)` | Copie une chaîne dans une autre                |
| `strcat(dest, src)` | Concatène deux chaînes                         |
| `strcmp(s1, s2)`    | Compare deux chaînes                           |
| `strchr(s, c)`      | Cherche un caractère dans une chaîne           |
| `strstr(s, t)`      | Cherche une sous-chaîne                        |

---
# TODAY
## Plan
1. Rappel : Algorithme vs programmation
2. E/S : La vérification des saisies
3. Les chaînes de caractères en C
4. .under[La bibliothéques Math en C]
5. Les commandes unix en C

---
# Math.h
## Illustration
Nous désirons faire un programme qui calcul la racine carrée et la puissance d'un nombre saisi par l'utilisateur :
```c
#include <stdio.h>
#include <math.h>
int main(){
 int a;
 float racine;
 int puissance;
 printf("veuillez saisir un nombre : \n");
 scanf("%d",&a);
 racine=sqrt(a);
 puissance=pow(a,2);
 printf("la racine de %d est %f \n",a,racine);
 printf("la puissance de %d est %d \n",a,puissance);

return 0;
}

```
---
# Math.h
## Illustration
Il faut rajouter :
```c
#include <math.h>
```

Une compilation classique ne fonctionne pas :
```shell
gcc -Wall monProgramme.c -o exe
```

Il faut rajouter le lien biblio (**-lm**) :
```shell
gcc -Wall monProgramme.c -o exe -lm
```

---
# TODAY
## Plan
1. Rappel : Algorithme vs programmation
2. E/S : La vérification des saisies
3. Les chaînes de caractères en C
4. La bibliothéques Math en C
5. .under[Les commandes unix en 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
## TODAY
- Gérer les chaînes de caractères
- Vérifier les saisies de l'utilisateur
- Résoudre des problèmes mathématiques
- Automatiser les traitements dans le terminal
- Visualiser une chaîne de caractères