Cours 3

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

---
# Inès de Courchelle
## Informatique 1
## Les fonctions et les procèdures

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

---
layout: false

# Aujourd'hui
## Objectifs
- Manipuler des prédicats
- Connaître la différence entre une fonction et une procédure
- Utiliser des fonctions/procédures dans un programme
- Résoudre des problèmes mathèmatiques avec des algos

---
# Plan
## Today
1. Rappel
2. Les fonctions
3. Les procédures
4. La visibilité des variables

---
# Plan
## Today
1. .under[Rappel]
2. Les fonctions
3. Les procédures
4. La visibilité des variables

---
# La composition
## Programme
- Il est l'unité de base d'un algorithme
- Il a un début et une fin

## 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 de caractères ...

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

---
#  Le nom des variables
## Pourquoi ?
- provoquer des bugs
- ajouter de la confusion
- rendre le code incompréhensible

## Bonnes pratiques
- Choisir des noms significatifs
- utiliser une convention (distanceEnKm ou distance_en_km)
- éviter les abréviations
- ne pas réutiliser les mêmes variables pour plusieurs rôles

---
# Instructions
## Interaction avec l'utilisateur
#### 2 types
- entrées : la saisie au clavier
- sorties : l'affichage à l'écran
#### Comment ?
- Récupérer la saisie clavier dans une variable : LIRE
- Afficher une information à l'écran : ECRIRE

---
# Instructions
## Interaction avec l'utilisateur
#### Exemple
.pull-left[
```
ECRIRE("Quel est ton age ?)
LIRE(age)
```
]
.pull-right[
```
ECRIRE("Quel est ton nom et ton prénom ?)
LIRE(nom)
LIRE(prenom)
```
]

.underR[ATTENTION] S'il y a plusieurs entrées, Alors il faut un **LIRE** pour chaque entrée

---
# Instructions
## Interaction avec l'utilisateur
#### Exemple complet
```
PROGRAMME Bonjour
VARIABLES
    nom,prenom : chaine de caractères
    age : entier
DEBUT
   ECRIRE("Quel est ton nom et ton prénom ?)
   LIRE(nom)
   LIRE(prenom)
   ECRIRE("Quel est ton age ?)
   LIRE(age)

ECRIRE("Bonjour, " + nom +" " + prenom +" tu as " + age +" ans")
FIN
```

---
# Instructions
## Interaction avec l'utilisateur
#### Exemple complet
<center>
<video src="../cm2/videos/demoES.mp4" width="400" height="300" controls poster="vignette.jpg">
Cette vidéo ne peut être affichée sur votre navigateur Internet.<br> Une version est disponible en téléchargement sous <a href="URL">adresse du lien </a> .
</video>
</center>

---
# Instructions
## Les conditions
.pull-left[
#### SI ...ALORS
```
SI [CONDITION est VRAI] ALORS
...
FIN SI
```

#### Si ... SINON SI...
```
SI [CONDITION est VRAI] ALORS
...
SINON SI [CONDITION est VRAI] ALORS
...
SINON
...
FIN SI
```
]
.pull-right[
#### SI ... SINON
```
SI [CONDITION est VRAI] ALORS
...
SINON
...
FIN SI
```
#### SELON
```
SELON [VARIABLE]
    CAS [VALEUR]:
    CAS [VALEUR]:
    CAS [VALEUR]:
    DEFAUT:
FIN SELON
```
]
---
# Instructions
## Les conditions
#### Exemple
```
PROGRAMME Basket
VARIABLES
    scoreElanBearnais,scoreOrleans : entier
DEBUT
    ECRIRE("Entrez le score de l'Élan béarnais")
    LIRE (scoreElanBearnais)
    ECRIRE("Entrez le score de l'Orleans")
    LIRE (scoreOrleans)

SI (scoreElanBearnais > scoreOrleans) ALORS
        ECRIRE("Victoire 🎉")
    SINON SI (scoreElanBearnais = scoreOrleans) ALORS
        ECRIRE ("Match nul 🤝")
    SINON
        ECRIRE ("Défaite... 😢")
    FIN SI
FIN
```
---
# Instructions
## Les conditions
#### Exemple
<center>
<video src="../cm2/videos/democondition.mp4" width="400" height="300" controls poster="vignette.jpg">
Cette vidéo ne peut être affichée sur votre navigateur Internet.<br> Une version est disponible en téléchargement sous <a href="URL">adresse du lien </a> .
</video>
</center>

---
# Instructions
## Une boucle
#### Pour
.pull-left[
Quand on sait combien de fois on veut réaliser une opération
]

.pull-right[
```
POUR i ALLANT de 0 à N FAIRE
...
FIN POUR
```
]

<br>

.underR[Attention : ] On prend l'habitude de faire commencer les boucles à 0

---
# Instructions
## Les conditions
#### Exemple
```
PROGRAMME Boucle
VARIABLES
    i: entier
DEBUT
    POUR i ALLANT de 0 à 10 FAIRE
        ECRIRE("tour N°i =" + i )
    FIN POUR
FIN
```
.underR[Attention : ]
- Ici, on va aller de 0 à 9 soit [0 ; 10 [
- Ne pas oublier de déclarer le i dans les variables

---
# Instructions
## Une boucle
#### Tant que Faire ...
.pull-left[
Quand on doit répéter une opération en fonction tant qu'une condition est vérifiée
]

.pull-right[
```
TANT QUE [CONDITION EST VRAI] FAIRE
...
FIN TANT QUE
```

]

<br>

#### Faire ... Tant que
.pull-left[

Quand on doit répéter une opération en fonction tant qu'une condition est vérifiée
]

.pull-right[
```
REPETER
...
TANT QUE [CONDITION EST VRAI]
```
]

---
# Instructions
## La blagounette
<img src="../cm2/img/lol.jpg" width=400>

---
# Instructions
## TANT QUE
#### Même programme

.pull-left[
```
PROGRAMME tantque
VARIABLES
    nb: entier
DEBUT

REPETER
       ECRIRE ("entrez un entier")
       LIRE(nb)
   TANT QUE (nb > 42)
FIN
```
]
.pull-right[
```
PROGRAMME tantque
VARIABLES
    nb: entier
DEBUT

ECRIRE ("entrez un entier")
    LIRE(nb)

TANT QUE (nb > 42) FAIRE
       ECRIRE ("entrez un entier")
       LIRE(nb)
   FIN TANT QUE
FIN
```
]

Les deux programmes font la même chose !!

---
# Plan
## Today
1. Rappel
2. .under[Les fonctions]
3. Les procédures
4. La visibilité des variables

---
# 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 du code
- automatiser des procesus
- diviser du code

---
# Les fonctions
## Cas d'étude
On considère le programme suivant :
<img src="img/exempleAddition.png" width=250>

---
# Les fonctions
## Cas d'étude
#### Problème
<img src="img/exempleAdditionRedondance.png" width=275>

---
# Les fonctions
## Comment faire ?
On va créer un bout de programme appelé fonction qui fonctionnera pour 2 nombres

---
# Les fonctions
## Représentation

**Attention** Une fonction n'a le droit de retourner qu'une seule et unique information

---
# Les fonctions
## Cas d'étude

---
# Les fonctions
## Cas d'étude

**Attention** Si le type de retour est un entier la variable retournée doit être un entier

---
# Les fonctions
## Dans le programme ?
#### AVANT
```c
PROGRAMME ADDICTION
VARIABLES
    a,b,resultat : entier
DEBUT
    a ← 1
    b ← 2
   resultat ← a + b

a ← 4
    b ← 5
    resultat ← a + b

a ← 8
    b ← 6
    resultat ← a + b

FIN
```

---
# Les fonctions
## Dans le programme ?
#### Maintenant
```c
FONCTION addition(a,b:entier): entier
VARIABLE
    resultat : entier
DEBUT
    resultat ← a + b
    RETOURNER resultat
FIN

PROGRAMME ADDICTION
VARIABLES
    resultat : entier
DEBUT
   resultat ← addition(1,2)
   resultat ← addition(4,5)
   resultat ← addition(5,3)
FIN
```

---
# Les fonctions
## Dans le programme
#### On peut encore simplifier la fonction !
<img src="img/simplification.png" width=300>

---
# Les fonctions
## Dans le programme
```c
FONCTION addition(a,b:entier): entier
DEBUT
    RETOURNER (a + b)
FIN

PROGRAMME ADDICTION
VARIABLES
    resultat : entier
DEBUT
   resultat ← addition(1,2)
   resultat ← addition(4,5)
   resultat ← addition(5,3)
FIN
```
---
# Les fonctions
## Appel de la fonction
Dans le programme, si une fonction est appelée alors le programme attend que la fonction soit terminée !

---
# Les fonctions
## Appel de la fonction
<img src="img/senarioArret/sc1.png" width=500>

---
# Les fonctions
## Appel de la fonction
<img src="img/senarioArret/sc2.png" width=500>

---
# Les fonctions
## Appel de la fonction
<img src="img/senarioArret/sc3.png" width=500>

---
# Les fonctions
## Appel de la fonction
<img src="img/senarioArret/sc4.png" width=500>

---
# Les fonctions
## Appel de la fonction
<img src="img/senarioArret/sc5.png" width=500>

---
# Les fonctions
## Appel de la fonction
<img src="img/senarioArret/sc6.png" width=500>

---
# Les fonctions
## La documentation !
Pour chaque fonctions nous devons définir :
1. Un **résumé** qui tient sur une ligne
2. Les **préconditions** : décrit la nature et l’ensemble des contraintes sur tous les paramètres d’entrée, aﬁn que la fonction puisse s’exécuter correctement
3. La **post-condition** : décrit le résultat produit par la fonction et ses contraintes éventuelles

---
# Les fonctions
## La documentation !
#### Dans notre exemple
```c
// Fonction qui permet d'additionner deux entiers
// Precondition : 2 entiers que l'on souhaite additionner
// Postcondition : 1 entier correspondant au résultat d'une addition

FONCTION addition(a,b:entier): entier
VARIABLE
    resultat : entier
DEBUT
    resultat ← a + b
    RETOURNER resultat
FIN
```

---
# Les fonctions
## Les prédicats
Les prédicats sont des fonctions qui renvoient un booleen

## Exemple
```c
// Fonction qui permet de vérifier si un entier est positif ou pas
// Precondition : 1 entier
// Postcondition : 1 booleen : vrai si a > 0 ou faux si a =< 0

FONCTION estPositif(a : entier) : booleen
DEBUT
    retourner (a > 0) //retourne le résultat booleen de a > 0
FIN
```

---
# Plan
## Today
1. Rappel
2. Les fonctions
3. .under[Les procédures]
4. La visibilité des variables

---
# 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 du code
- automatiser des procesus
- diviser du code

---
# Les procédures
## Cas d'études
<img src="img/procCasEtude.png" width=500>

---
# Les procédures
## Cas d'études
#### Problème
<img src="img/procCasEtudeRedon.png" width=500>

---
# Les procédures
## Comment faire ?
On va créer un bout de programme appelé procédure qui fonctionnera pour n'importe quel nom et prénom !

---
# Les procédures
## Représentation
**Attention** Pas de retour !

---
# Les procédures
## Exemple
<img src="img/templateBonjour.png" width=300>
<img src="img/bonjour.png" width=300>

---
# Les procédures
## Cas d'études
<img src="img/algoBonjour.png" width=600>

---
# Les procédures
## Cas d'études
#### Avant
<img src="img/procCasEtude.png" width=500>

---
# Les procédures
## Cas d'études
#### Après
<img src="img/procResolue.png" width=500>

---
# Les procédures
## La documentation !
Pour chaque procédure, nous devons définir :
1. Un **résumé** qui tient sur une ligne
2. Les **préconditions** : décrit la nature et l’ensemble des contraintes sur tous les paramètres d’entrée, aﬁn que la procédure puisse s’exécuter correctement
3. La **post-condition** : décrit le résultat produit par la procédure

---
## La documentation !
#### Dans notre exemple
```c
// Procédure qui permet d'afficher un message personnalisé à une personne
// Precondition : 2 chaînes de caractères pour le nom et le prénom
// Postcondition : Affiche bonjour avec le nom et le prénom passés en paramètre

PROCEDURE bonjour(nom, prenom : chaine de caractères)
DEBUT
    ECRIRE("Bonjour " +prenom + " " + nom + " " + "ça va ?")
FIN
```

---
# Plan
## Today
1. Rappel
2. Les fonctions
3. Les procédures
4. .under[La visibilité des variables]

---
# Visibilité des variables
## c'est quoi ?
La visibilité des variables correspond à l’endroit où une variable peut être utilisée (accessible) dans le programme.

## Où ?
Dans un programme, une procédure ou une fonction

## Comment ?
Avec un exemple ...

---
# Visibilité des variables
## Exemple 1
```c
FONCTION multiplication(a,b:entier):entier
DEBUT
    retourner (a * b)
FIN

PROGRAMME Exemple 1
VARIABLES
    resultat,a,b : entier
DEBUT
   ECRIRE("Entrez un entier ")
   LIRE(a)

ECRIRE("Entrez un entier ")
   LIRE(b)

resultat ← multiplication(a,b)

ECRIRE("le resultat de "+ a +" fois " + b +" est " + resultat)

FIN
```

---
# Visibilité des variables
## Exemple 1
<img src="img/multiplication.png" width=500>

---
# Visibilité des variables
## Exemple 1

---
# Visibilité des variables
## Exemple 2
```c
PROCEDURE affichage(age : entier)
DEBUT
    ECRIRE("Bonjour, tu as "+age+"ans")
    age ← age +1
    ECRIRE("Joyeux anniversaire, tu as 1 an de plus")
FIN

PROGRAMME visibilite
VARIABLE :
    age : entier
DEBUT
    ECRIRE("Quel age as-tu ?")
    LIRE (age)
    affichage(age)
    ECRIRE("mon age est :" + age)
FIN
```