Cours Algorithmique 1ère Année

Université Cheikh Anta Diop de Dakar
Ecole Supérieure Polytechnique GE

Département Génie Electrique
1ère Année DUT EEAIT & L1 GE
Novembre 2022 – Janvier 2023
Prof: M. Salif Sagana FALL

[email protected]
Algorithmique, Programmation
Objectifs du module : Maîtriser la démarche d’élaboration

d’une application informatique simple.
Compétences professionnelles à acquérir :

• Utilisation d’un Micro-ordinateur (fichiers, machines en réseau)
• Réalisation d’un programme :
– repérer les objets traités et les caractériser (données et types simples);
– repérer les traitements nécessaires et leur organisation (instructions);
– organiser l’application (fonctions : résultat, paramètres, prototypes);
– Il est souhaitable de donner dès le premier programme de bonnes habitudes.
• Utilisation d’un langage évolué et d’un environnement de
développement intégré :
– édition et documentation des fichiers source;
– compilation, utilisation des librairies basiques, édition de liens;
2
– mise au point des programmes.
Exemple de stages de fin d’études
Programmes en C pour piloter des équipements :
Commande d’un variateur Pilotage d’appareils de

de puissance via la ligne mesure en Mécanique
téléphonique
Interfaces Windows :
Supervision d’une
Pilotage d’appareils de machine de fabrication
mesures électriques de câbles électriques
3
Chapitre A : Introduction à la Programmation
1- L’ORDINATEUR
1.1- L’Ordinateur et ses Périphériques
1.2- Le Logiciel et le Matériel
2- L’INFORMATIQUE
2.1- L’Industrie Informatique
2.2- Les Métiers de l’Informatique
3- LA PROGRAMMATION
3.1- En quoi consiste la Programmation ?
3.2- Comment Programmer ?
4- PROGRAMME / ALGORITHME
4.1- Description d’un Programme
4.2- Comment inventer un Programme ?
Définition de l’Ordinateur
Ordinateur : Machine électronique,

communicante, programmable permettant
de traiter automatiquement tous les types
d’information.
5
Les constituants d’un ordinateur
Ordinateur : système de traitement automatique
de l’information
1) Microprocesseur, CPU (Central Processing 4) Mémoire Cache
Unit), UC (Unité Centrale de traitement)
Registres
3) Bus Système
 Unité de commande
 Unité de Contrôle 2) Mémoire Centrale
UAL,ALU RAM (Random
Unité de calcul Access Memory)
ROM (Read
Only Memory)
6
Les périphériques d’un ordinateur
Ordinateur : système communicant

MICRO-ORDINATEUR
BUS SYSTEME
CPU RAM
INTERFACES d’E/S
INTERFACES INTERFACES INTERFACES
d’Entrées d’Entrées-Sorties de sorties
E/S: stockage transmission S: affichage
E: saisie PERIPHERIQUES
Équipements informatiques ou industriels
7
Les 2 couches d’un système informatique
2. Logiciel (Software)
= haut niveau,
interface utilisateur,
programmes, vers
langage humain
1. Matériel (Hardware)
= bas niveau, constituants physiques de
l’ordinateur, vers langage binaire
8
ORDINATEUR ISOLE ORDINATEUR PILOTANT UN ORDINATEUR
EQUIPEMENT INDUSTRIEL EN RESEAU
INTERNET
RLE / RLI
Conception
Fabrication
Utilisation :
- dépannage - Type de communication - Structures réseaux
- utilisation d’applications
- Développement -Intranet / WEB
- développement du SE
d’applications - applications
- développement logiciel réseau
de communication
9
Définition de l’Informatique
Informatique : Science du traitement de

l'information par des moyens automatiques.
La discipline Informatique traite des aspects :

 théoriques et pratiques, liés aux couches
matérielles et logicielles dans un ordinateur.
 conception, fabrication et utilisation des
ordinateurs.
10
L’évolution de l’Informatique
L’Industrie Informatique a décollé après la 2°

guerre mondiale.
Elle vient de loin : Schickard 1623, Falcon 1728
Les grands noms associés : El Khawarizmi, Pascal,

Babbage, Ada Byron, Boole, Hollerith, Fleming, Turing,
Shannon, Zuse, Aiken, Eckert & Mauchly, Von Neumann,
Bardeen & Brattain & Shockley, Kilby...
11
L’évolution de l’Informatique
L’Industrie Informatique a décollé après la 2°

guerre mondiale.
Elle vient de loin : Schickard 1623, Falcon 1728
Les grands noms associés : El Khawarizmi, Pascal,

Babbage, Ada Byron, Boole, Hollerith, Fleming, Turing,
Shannon, Zuse, Aiken, Eckert & Mauchly, Von Neumann,
Bardeen & Brattain & Shockley, Kilby...
Des progrès technologiques fulgurants, en 30 ans :
CPU 30 000 fois plus rapide

13
ENIAC, 1945 (Eckert &Mauchly)
- 30 tonnes, 170 m2 - quelques kilos, <1m²
- électronique (environ 18 000 tubes à vide) - milliard de transistors
L’Informatique de nos jours
L’Informatique est quasiment incontournable dans

notre vie quotidienne et dans la vie économique :
Trouver des infos sur le WEB y faire des achats
Piloter une chaîne de production Superviser un process
Concevoir des circuits électroniques Jouer
Communiquer par e-mail Réaliser un rapport WORD
Connaître l’outil informatique sera de plus en plus

nécessaire et, ceci, avec une formation continue.15
Les Secteurs de l’Informatique
Informatique Réseaux Multimédia Génie

Industrielle (RLE, (WEB, jeux, Logiciel
(Pilotage d’automates, Intranet, spectacles) (Mécanique,
conduite de processus, Internet...) Météorologie...)
systèmes embarqués...)
Informatique de gestion
(bases de données...)
Bureautique
(tableurs...)
hardware software
16
Le Technicien et l’Informatique en Entreprise
Piloter des équipements

(supervision, régulation) Gérer la configuration de
systèmes informatiques
(architecte système)
Développer des logiciels
(analyste-programmeur)
Administrer un réseau
Réparer et tester le d’ordinateur
matériel (maintenance,
support technique, SAV)
Développer des sites WEB

Vendre du matériel (WebMaster)
informatique
17
La Programmation est indispensable
L’ordinateur calcule très vite :
des millions de fois plus rapide que notre cerveau.
L’ordinateur n’est pas du tout intelligent :

simple automate.
L’ordinateur est un automate programmable :

le programmeur lui donne, avec la programmation,
l’intelligence pour résoudre certains problèmes.
Programmation : développement de programme

(logiciel ou application) exécuté automatiquement par
l’ordinateur
18
Le langage de Programmation
L’ordinateur doit comprendre (pouvoir exécuter) le
programme, qui va lui permettre de réaliser une tâche.
Le programme doit être écrit dans un langage de

programmation (syntaxe très stricte). Ce langage est
traduisible dans le langage de l’ordinateur (binaire) par un
logiciel de traduction (compilation + édition de liens).
Intelligence Artificielle, Langages Objets,

langages évolués: Langages fonctionnels, Langages
procéduraux (algorithmiques)
langages machine: Assembleur, Binaire
Langage C (procédural ou algorithmique) :

créé en 1978, surtout utilisé en Informatique Industrielle.19
Comment informatiser une Tâche ?
Le programme doit calculer le prix de 2 produits
nb2 produit2 à prix2 FCFA

TRAITEMENT Prix total
nb1 produit1 à prix1 FCFA
prixTotal= nb1 x prix1 + nb2 x prix2
Informatisation d'une tâche 

1. identifier les données à manipuler (Entrées et Sorties) ;
2. obtenir les résultats par un traitement sur les données.
L’écriture du traitement dépend des opérations élémentaires du
langage de programmation. 20
Les étapes de la programmation
Programmer = concevoir, écrire et tester un
programme répondant à un cahier des charges.
Programme
Programmeur
Etapes de programmation :
1. Bien étudier le cahier des charges
2. Inventer une solution logique pour l’ordinateur
3. Traduire cette solution dans un langage de programmation
4. Tester, corriger et valider le programme 21
Programme = Recette de cuisine
5 œufs entier tabOeuf[5]
125g farine entier farine = 125
125g sucre entier sucre= 125
1cc levure entier levure= 1
1. Mélanger sucre et jaunes Melange= sucre

POUR i de 0 à 4
melange=melange + jaune(tabOeuf[i])
FPOUR
2. Chauffer bain marie
FAIRE
jusqu’à blanchissement
couleur = chauffage(melange)
TANT QUE (couleur ≠ blanc)
3. Laisser refroidir refroidir(melange)
4. Ajouter farine et levure melange = melange + farine + levure
5. Ajouter blanc en neige melange = melange+ blanc(tabOeuf)
6. Cuire au four 180°, 40mn gateau = cuire(melange,180,40) 22
Définition du programme
Programme : Suite d’instructions (partie traitement à

effectuer, décomposée en opérations élémentaires)
manipulant des données (partie informations à traiter).
Exemples d’instructions :
 écrire une valeur dans la RAM,
 effectuer un calcul,
 lire des données tapées au clavier,
 écrire des informations sur l’écran...
23
Les 3 formes de programme
ORDINATEUR
PAPIER RAM
ALGO Comptage
DISQUE DUR
void main() 1100 0000
...
DEBUT
{ ... 1000 0000
langage C
langage
... naturel ... binaire
FIN } 1000 0110
Fichier source Exécutable

Algorithme
TD TP
24
L’Algorithme en langage naturel
ALGO Comptage
CONSTANTE MAX= 10 (entier)
VARIABLE choixMenu (carac), compteur (entier)
DEBUT
FAIRE
Afficher le menu
Saisir la valeur tapée au clavier et la ranger dans choixMenu
CHOISIR en fonction de choixMenu
choixMenu vaut ‘a’ : POUR compteur de 0 à MAX
Afficher la valeur de compteur
FPOUR
TANT QUE l’utilisateur n’a pas choisi de sortir
FIN 25
Le Programme source en langage C
void main(void)
{
const int MAX=10 ;
int compteur ; char choixmenu ;
do
{ clrscr() ;
printf("\n\n\t\ta- Compter\n\t\tb- Sortir du programme\n\t\tChoix : ") ;
scanf("%c",&choixmenu) ;
switch(choixmenu)
{ case ‘a’ : for (compteur=0 ;compteur<=MAX ;compteur++)
printf("\n\t%d",compteur) ;
getch();
}
} while (choixmenu !=‘b’) ;
} 26
Le Programme exécutable en binaire
RAM
1100 0000 0000 1111
1000 0000 0000 1010
1000 0110 0000 0000
27
Intérêt de l’Algorithme
Ecrit avec un langage naturel et simple.

Le programmeur n’a pas à réfléchir à la façon d’écrire, mais
peut se concentrer sur la recherche d’une solution. Il dissocie
les difficultés de syntaxe du C et de réflexion logique.
Permet de commenter rapidement son code.

Des rapports de conception sont ainsi produits facilement,
pour l’entreprise et pour le client.
Réfléchir d’abord sur papier permet d’avoir une vue

d’ensemble de la solution.
Ceci permet d’éviter à avoir à recommencer un programme
très mal parti ! 28
L’Ecriture d’un Algorithme
1. Identifier les données (Entrées et Sorties) du traitement.

2. Trouver une bonne séquence d’instructions pour réaliser
le traitement (trouver les bonnes instructions et leur ordre).
3. Identifier de nouvelles données internes au traitement.
RECETTE de CUISINE : RECETTE de CUISINE :

1. Lister la nature et la quantité 2. Préciser les opérations
des ingrédients à utiliser. avec leur ordre d’exécution.
29
Il existe toujours des
variantes, des
marques personnelles
dans un programme
Décomposer les
traitements complexes
Trouver les bonnes

instructions et bien
les enchaîner
Connaissance des
instructions et données
utilisables
L'algorithmique, vous la pratiquez tous les
jours et depuis longtemps…
Définition
Un algorithme est une description en langage naturel de la
suite des actions effectuées par un programme.
Exemple 1 : Traverser une route à deux sens de circulation
1. _ _ _ _ _ _ _
2. _ _ _ _ _ _
3. _ _ _ _ _ _
4. _ _ _ _ _ _ _
5. _ _ _ _ _ _ _
6. _ _ _ _ _ _ _
7. _ _ _ _ _ _ _
8. _ _ _
31
Représentation graphique d’un algorithme
Pour permettre une représentation facile, toutes les étapes d’un

algorithme sont représentées schématiquement.
1. Début et fin sont représentés par:
Début
Fin
2. Une action est représentée par un rectangle dans lequel est

inscrit l’action Action(s)
3. Une condition est schématisée par un losange dans lequel est

inscrit la condition et à côté, les réponses possibles non
Condition
oui
4. Le recueil ou la fourniture d’information est schématisé par

un parallélogramme dans lequel est mentionné l’information
E/S données
32
Exemple 2: Résolution d’une équation du 2nd degré: ax2+bx+c=0

Avec a≠0
  b 2  4ac
b  b 
si   0 x1  et x 2 
2a 2a
b j  b j 
si   0 x1  et x 2 
2a 2a
avec
b
e x1  e x2  
2a
 
m x1   et m x2 
2a 2a 33
Exemple 2: Résolution d’une équation du 2nd degré: ax2+bx+c=0
Début
Algo Trinome // Nom

a, b, c
a=0
Δ  b*b - 4ac
non oui
Δ≥0
b  b  b 
 e xi  et m xi  x1  et x2 
2a 2a 2a 2a
e xi , m xi x1, x2
Fin
34
Les grandes étapes de Programmation

2. Concevoir une solution logique: algorithme
3. Traduire la solution dans un langage de programmation

4. Tester le programme dans tous les cas de figure
35
La structure de base d’un Algorithme
ALGO Nom
déclaration données
DEBUT
// commentaires
instruction 1
instruction 2
…
FIN
Règle de programmation :
 Indentations,
 Commentaires explicatifs utiles. 36
Chapitre B : Les Données dans un Programme
1- QUE SONT LES DONNEES SIMPLES ?
1.1- Les Données simples
1.2- Variables et Constantes
1.3- Les Types de Données
2- COMMENT UTILISER LES DONNEES SIMPLES ?
2.1- Déclaration de Variables
2.2- Déclaration de Constantes
2.3- Initialisation de Variables par Affectation
3- DES DONNEES COMPLEXES : LES TABLEAUX
3.1- Définition
3.2- Déclaration
3.3- Initialisation par Affectation
Définition d’une Donnée simple
Une donnée permet de manipuler des quantités de

diverses natures (valeurs entières, réelles...).
Une donnée est caractérisée par :

 Un nom …………………Mme Fall
 Une valeur ……………..1 lettre
 Une adresse ……………..6 Moussé Diop
38
Description d’une Donnée simple
Pour exister une donnée doit être associée à une zone
mémoire de la RAM (CONTENEUR)
&a a 10
Le conteneur est identifié par un nom, qui permet de

manipuler la donnée dans le programme, exemple : a
Le contenu du conteneur est la valeur de la donnée,
exemple : 10
L’adresse mémoire du conteneur permet à
l’ordinateur d’accéder à la variable dans la RAM,
exemple : &a 39
Exemples de Données simples
données a, b et c pour faire un calcul :

RAM
c= a+b &a a 3
&b b 2
&c c 5
• Données de nom a, b et c
• Valeurs entières : a vaut 3, b vaut 2 et c vaut 5
• Adresses des données dans la RAM : &a, &b, &c
40
Différence entre Variables et Constantes
Variable : donnée dont la valeur peut varier en cours

d’exécution du programme : sa valeur peut être
changée plusieurs fois pas les instructions.
Exemple : si un programme contient

c= a+b, c est forcément une variable
Constante : donnée dont la valeur ne peut pas

varier en cours d’exécution du programme : sa
valeur est fixée en début de programme, puis ne peut
plus être changée par les instructions.
41
Intérêt des Constantes
Pourquoi utiliser des constantes pour des données fixes?

• Le nom explicite d’une constante dans une instruction est
plus lisible qu’une valeur ;
• Pour une valeur utilisée plusieurs fois dans le programme, il

est plus simple de la déclarer une seule fois pour la
maintenance du programme.
Exemple :
prixTTC = prixHT  1.18 prixTTC= prixHT (1+TVA)
42
Définition du Type
Le Type d’une donnée définit sa nature.
Il caractérise :
 La taille de sa zone mémoire ………………..... 1 octet
 L’ensemble des valeurs possibles …………… [0,255]
 Les opérateurs applicables à cette donnée ….. + -
43
Illustration des caractéristiques du Type
L’ensemble des valeurs possibles est lié, notamment,
à la taille de la zone mémoire de la donnée :
&a a 1010 a 0000 10102

1 octet (8 bits)
&a a 25610 IMPOSSIBLE !

1 octet (8 bits)
&a a 25610 a 0000 0001 0000 00002

2 octets (16 bits)
POSSIBLE
44
Les différents Types simples
Une donnée peut être de l’un des types suivants :

• Entiers, signés ou non signés, court (2 octets) ou long (4)
• Réels, simple précision (4 octets) ou double précision (8)
• Caractères associés à des codes ASCII entiers
• Booléens : valeur logique VRAI ou FAUX
Entier Réel Caractère Booléen
0 0.0 (0.) ‘a’ (0x61) VRAI
10 2035.59 ‘5’ (0x35) FAUX
-30 000 -5.68975 ‘!’ (0x21) TRUE
66 000 1 000 568.5 CR (0x0D) FALSE
45
Liste des Types simples
En C (C++) TYPE CAPACITE TAILLE (octet)
char caractère NUL à ÿ (codes ASCII: 0…255) 1
bool booléen VRAI / FAUX (true/false) 1
unsigned short entier non signé court [0,65 535] 2
short entier signé court [-32 768,32 767] 2
unsigned int entier non signé long [0,4 294 967 295] 4
int (long) entier signé long [-2 147 483 648, 2 147 483 647] 4
float réel simple précision [+- 3.4 10 38, +- 3.4 1038] 4
double réel double précision [+-1.7 10 308, +-1.7 10308 ] 8
46
Exemples de données associées à un Type
Entier non signé court : &a a 0...65535

(unsigned short) 2 octets (16 bits)
Entier signé court :&a a -32 768...32 767

(short) 2 octets (16 bits)
NUL...ÿ
Caractère : &a a 0...255
(char)
1 octet (8 bits)
47
Instruction de Déclaration de Variable
Rôle: l’instruction de déclaration de variable permet

d’indiquer les variables que le programme pourra manipuler.
Instruction (partie donnée) : VAR type nomVariable

Exécution par le CPU: réservation d’un espace mémoire
vide, dont la longueur dépend du type.
Règle de programmation : ALGO DéclarerVariable

// partie déclaration des données
Noms significatifs, pas trop long
VAR caractère reponse
1° lettre en minuscule
entier court a, b
DEBUT // début des instructions
FIN
48
Instruction de Déclaration de Constante
Rôle: l’instruction de déclaration de constante permet

d’indiquer les constantes que le programme pourra utiliser.
Instruction (p. donnée): CONST type nomConst=val

Exécution par le CPU: réserve un espace mémoire (sa
longueur dépend du type) et le remplit avec la valeur val.
Règle de programmation : ALGO DéclarerConstante

// partie déclaration des données
Noms significatifs, pas trop long
CONST caractère FINPG= ‘b’
Tout en majuscules
rsp PI= 3.14
DEBUT // début des instructions
FIN
49
Instruction d’Affectation
Rôle: l’instruction d’affectation permet d’attribuer une

valeur à une variable.
Instruction : nomVariable  valeur

(partie données ou instructions)
Exécution par le CPU: la valeur à droite du signe

d’affectation (=) est stockée dans la case mémoire de la
variable à gauche du signe d’affectation.
50
Affectation pour initialiser une Variable
L’affectation peut-être utilisée pour initialiser une

variable : lui donner une valeur au début ou dans le programme.
surface
ALGO InitialiserVariable &surface 0.
// 1) lors de la déclaration
reponse
VAR rsp surface =0.
carac reponse
&reponse 0.
DEBUT
// 2) dans les instructions
reponse  ‘a’ reponse
‘a’
... &reponse
FIN
51
MECANISME TYPE : Mémoire tampon
Le programme doit intervertir deux valeurs
a 5 b 2
ALGO IntervertirVariables
VAR ensc a= 5, b=2
DEBUT La variable a est
ab
ba
écrasée : son contenu a
FIN été perdu !
a 2 b 2 52
a b Il faut sauver le contenu de a

5 2 dans une variable tampon
avant d’écrire dedans.
VAR ensc a= 5, b=2, temp
a 5 b 2
DEBUT
temp a
ab
b temp
FIN
temp 5
53
a b Il faut sauver le contenu de a

5 2 dans une variable tampon
avant d’écrire dedans.
VAR ensc a= 5, b=2, temp
DEBUT
temp a a 2 b 5
ab
b temp
FIN
temp 5
54
Ce qu’est un tableau
Tableau : suite de cases mémoires permettant de

stocker les éléments du tableau, qui sont des données
de même type simple.
Un tableau à une dimension est un vecteur : les cases

sont alignées en une ligne ou en une colonne.
Exemple : tableau de 3 cases contenant des ensc

2 octets 2 octets 2 octets
cases stockant les éléments du tableau
2 5 4 = conteneurs mémoire correspondant
à des données de type simple
6 octets
55
Manipuler un tableau
tab[0]
&tab[0] 2
Nom des cases Donnée de type simple
du tableau
tab[0] tab[1] tab[2]
tab 2 5 4
Indices relatifs
Nom du tableau 0 1 2
des cases du
tableau
tab[0]
&tab[0] 2
tab[1] RAM
&tab[1] 5
tab[2]
&tab[2] 4
Adresses des cases du tableau 56

Instruction de Déclaration de Tableau
Rôle: l’instruction de déclaration de tableau indique les

tableaux où le programme stocke des données de type simple.
Instruction (partie donnée) :

VAR type nomVarTableau[nombre de cases]
vide de longueur: nombre de cases X longueur type.
ALGO DéclarerTableau
Règle de programmation : // partie déclaration des données
Noms significatifs, pas trop long VAR esl tabMesures[100]
Préfixe « tab » rdp tabNotes[50]
DEBUT // instructions
FIN 57
Initialisation d’un Tableau dans la partie Donnée
Dans la partie Données exclusivement, lors de la

Déclaration du tableau, il est possible d’attribuer une valeur à
chaque case du tableau par affectation :
ALGO InitialiserTableau
// lors de la déclaration, dans la partie données
VAR esl tabMesures[10]= {-2, 6, 100, -50, 0, 0, 1, 8, 45, -42}
rdp tabNotes[5]= {10.5, 20, 5, 14.5, 18}
DEBUT
FIN
tabMesures -2 6 100 -50 0 0 1 8 45 -42
tabNotes 10.5 20 5 14.5 18

58
ALGO Nom
DEBUT
// commentaires
instruction 1
instruction 2
…
FIN
 Indentations,


60
Chapitre C : Les Entrées/Sorties d’un Programme
1- DEFINITION DES ENTREES/SORTIES
1.1- Que sont les Entrées/Sorties ?
1.2- Différentes E/S classiques
2- SAISIES CLAVIER
2.1- Instruction de Saisie
2.2- Saisies multiples
3- AFFICHAGES ECRAN
3.1- Instruction d’Affichage
3.2- Gestion d’écran
Définition des Entrées / Sorties
Les Entrées/Sorties sont ici les échanges

d’informations (texte, valeurs numériques,
multimédia) entre le programme et un
équipement externe à l’ordinateur (périphérique
ou équipement industriel).
Les E/S permettent :

 à l’utilisateur de communiquer avec le programme
 de piloter un équipement avec l’ordinateur
62
Exemples d’Entrées / Sorties
saisie
ALGO Communiquer Entrée (ex: clavier, automate)
VAR ensc a, b VALEURS de a, b
rsp c
DEBUT affichage
(ex: écran, automate)
Sortie
… VALEUR de c
stockage,
transmission
FIN de l’information
Entrée/Sortie
(ex: disque dur, modem)
 Programme sur
l’Ordinateur
 Périphérique
 Equipement
63
Communication Programme / Fichiers
Le programme lit (Entrée) ou écrit (Sortie) des

données dans des fichiers sur le disque dur.
S : écriture
PROGRAMME
E : lecture
64
Communication Programme / Système
Le programme lit les données capteurs (Entrée) ou

envoie des commandes (Sortie) vers le système
automatisé.
PARTIE OPERATIVE
S : commandes
SYSTEME
DE SYSTEME A PILOTER
ACTIONNEURS AUTOMATIQUEMENT
COMMANDE
E : mesures CAPTEURS
65
Communication standard Programme / Utilisateur
Le programme lit des données sur le clavier (Entrée)
ou écrit des informations sur l’écran (Sortie).
ALGO
E : SAISIE CLAVIER DEBUT
...
FIN
Clavier
ALGO
DEBUT
...
FIN S : AFFICHAGE ECRAN
Ecran
66
Instruction de Saisie Clavier
Rôle: l’instruction (fonction) de saisie clavier lit une valeur

tapée au clavier par l’utilisateur du programme, afin de
l’affecter à une variable.
Elle permet à l’utilisateur de fournir des valeurs pour
initialiser des variables du programme.
Instruction (partie instruction) :

SAISIR(&nomVariable)
67
Exécution d’une Saisie Clavier
Exécution par le CPU :

/* initialisations d’une variable 1. Arrivé à l’instruction de Saisie,
par saisie clavier */
ALGO SaisirVariable le CPU attend de détecter la
VAR carac reponse touche RC en Entrée.
DEBUT 2. Dès qu’une valeur est disponible,
/* saisie de la valeur de le CPU la stocke dans la zone
reponse */ mémoire de la variable reponse.
Saisir(&reponse)
FIN
reponse
CPU
&reponse ‘b’
Clavier RAM
68
Précision : Détection de la touche RC en Entrée (1)
La détection de la touche RC dépend du type de la

variable saisie :
1. Pour la saisie d’un nombre : le CPU ne stockera une

donnée dans la RAM que lorsque l’utilisateur aura tapé un
nombre, puis RC.
Le CPU exécute
le Saisir()
‘-’ ‘4’ ‘5’ RC -45
BUFFER du clavier RAM
Clavier
69
Précision : Détection de la touche RC en Entrée (1)
La détection de la touche RC dépend du type de la

variable saisie :
2. Pour la saisie d’un caractère : l’utilisateur doit taper
un caractère, puis RC pour terminer la saisie ; mais si le
caractère RC traîne dans le buffer du clavier, le CPU est
automatiquement débloqué et stocke RC dans la
variable.
LeLe
CPUCPU exécute
exécute
le le
Saisir()
Saisir()
RC
‘A’ RC RC
‘A’
BUFFER du clavier RAM
Clavier
Il faut vider le buffer avant une saisie de caractères.70

Précisions : Passage d’une adresse à Saisir()
Il faut passer l’adresse de la variable à la fonction

Saisir() : paramètre en Entrée/Sortie = la variable est
modifiable par la fonction Saisir().
reponse
&reponse Clavier
DEBUT PROGRAMME E
Saisir(&reponse) DEBUT SAISIR()
…
… FIN SAISIR()
FIN PROGRAMME reponse
&reponse ‘A’
71
Description d’une saisie multiple
SAISIR (&variable1,&variable2,&variable3,…)
Au clavier, l’utilisateur doit :

1. Pour la saisie de nombres : l’utilisateur doit séparer
chaque nombre par la touche ESPACE, TAB ou RC ; il
doit terminer la saisie avec RC.
2. Pour la saisie de caractères : l’utilisateur doit taper les
caractères sans séparateur et terminer la saisie avec RC.
72
Instruction d’Affichage Ecran
Rôle: l’instruction (fonction) d’affichage écran écrit du texte

et/ou des valeurs de données sur l’écran.
Elle permet à l’utilisateur de visualiser les résultats du
programme.

AFFICHER("texte", nomVariable1, ...)
73
Exécution d’un Affichage Ecran

1. Arrivé à l’instruction
/* affichage de texte et d’une valeur de d’Affichage: il affiche le
variable sur l’écran */ texte, là où se trouve le
ALGO Afficher
curseur de l’écran.
VAR esc temperature
DEBUT 2. À la suite du texte, il
// saisie de la valeur de temperature affiche la valeur de la
Saisir(&temperature) variable temperature.
Afficher("Resultat: ",temperature)
FIN
Resultat: 15
temperature CPU
& temperature
15
Ecran
74
Précisions : Passage d’un nom de variable à Afficher()
Il faut passer le nom de la variable à la fonction

Afficher() : paramètre en Entrée = la variable n’est
pas modifiable par la fonction Afficher().
5
resu
Ecran
5
DEBUT PROGRAMME E
DEBUT AFFICHER()
Afficher(resu)
…
… FIN AFFICHER()
FIN PROGRAMME resu n’a pas pu être modifié par Afficher()
75
Déplacements du Curseur sur l’écran
Le curseur de l’écran se déplace de haut en bas, de gauche à
droite.
Le programmeur doit gérer l’écran :
• Commande pour aller en début de ligne suivante ("\n" en C)
• Commande pour indenter: tabulation horizontale ("\t" en C)
• Fonction pour effacer l’écran (fonction clrscr() en C)
• Fonction pour se positionner en un point de coordonnées
(x,y) (fonction gotoxy(x,y) en C)
(1,1) (80,1)
x
(1,25)
y 76


77
ALGO Nom
DEBUT
// commentaires
instruction 1
instruction 2
…
FIN
 Indentations,
Chapitre D : Calculer dans un Programme
1- DESCRIPTION DES CALCULS
1.1- Instruction de Calcul
1.2- Différents types de Calculs
1.3- Evaluation d’un Calcul
2- CALCUL ARITHMETIQUE, BINAIRE, LOGIQUE

2.1- Calcul Arithmétique
2.2- Calcul Binaire
2.3- Calcul Logique
Instruction d’Affectation
Rôle: l’instruction d’affectation permet d’attribuer une

valeur à une variable.
Instruction : nomVariable  valeur

Ou nomVariable = valeur
(partie données ou instructions)
Exécution par le CPU: la valeur à droite du signe

d’affectation (= ou ) est stockée dans la case mémoire de
la variable à gauche du signe d’affectation.
80
Affectation pour initialiser une Variable
L’affectation peut-être utilisée pour initialiser une

variable : lui donner une valeur au début ou dans le programme.
surface
ALGO InitialiserVariable &surface 0.
// 1) lors de la déclaration
reponse
VAR rsp surface= 0.
carac reponse
&reponse 0.
DEBUT
// 2) dans les instructions
reponse ‘a’ reponse
‘a’
... &reponse
FIN
81
Instruction de Calcul
L’Affectation permet aussi de récupérer le résultat

d’un calcul :
Rôle: l’instruction de calcul permet de faire un

calcul arithmétique, binaire ou logique.

nomVariable expression
expression est la formule de calcul.

82
Exécution de l’Instruction de Calcul

a b
resu= a-b &a 3 &b 2
1
1. Calcul du résultat : évaluation
de la valeur de expression (a-b) UAL,ALU
par l’ALU :
3 2
2. Stockage du résultat :
affectation de la valeur obtenue resu
dans la variable (resu) à gauche
du signe d’affectation (= ou ) &resu 1
: 83
Rôle des différents types de Calcul
Type Opérateurs Utilisation Données

de calcul
Arithmétiques Calculs entiers
Arithmétique +-x/% mathématiques ou réels
de comparaison
Logique ==  > <   Conditions E= tout
booléens logiques S=booléen
NON ET OU
Binaire binaires Calculs bit à bit entiers
+ . 
84
Exemples d’Expressions Arithmétiques, Binaires et Logiques
Expressions arithmétiques :
(a x b + 3) / c
a%b
Expressions binaires :
a+b
(c  b) . ā
Expressions logiques :
a == b
a > b ET a ≥ c
a ET b OU NON(c)
85
Règles d’évaluation
L’évaluation d’un calcul par le CPU suit les règles :

1. L’ordre de calcul dépend des parenthèses, qui forcent les priorités ;
2. L’ordre de calcul dépend, ensuite, de la priorité des opérateurs ;
3. Pour un même niveau de priorité, l’évaluation de l’expression se fait
de gauche à droite (à partir de l’opérateur d’affectation = ou ).
2
1
Que fait le processeur avec : resu= 4 / 2 / 2 ?
Que fait le processeur avec : resu= 4 + 2 x 2 ?
8 4 86
Priorité des Opérateurs
Priorité Opérateur
1 ()
2 NON (non logique) — (complément à 1)
3 x (multiplication) / (division) % (modulo)
4 + (addition) - (soustraction)
5 < >  
6 == (égalité) (différent)
7 .(et binaire)
8 (ou exclusif)
9 + (ou binaire)
10 ET (et logique)
11 OU (ou logique)
12 = (affectation)
87
Différence entre = (Affectation) et = = (Egalité)
Il ne faut pas confondre les opérateurs = et = = !!
Opérateur d’Affectation : = Opérateur d’Egalité : = =
• pour attribuer une • pour comparer les
valeur à une variable valeurs de 2 données
• ECRITURE • LECTURE
a= 0 a= = 0 FAUX a 2
RAM
a ==
&a 0
0 2
• écrit 0 dans la RAM • lit la valeur de a dans la
pour la variable a. RAM et la compare à 0.
88
Description des Calculs Arithmétiques
Calculs arithmétiques :
• Opérations : addition (+), soustraction (-), division (/),
multiplication (x), modulo (%).
• Si les opérandes sont entiers, le résultat est de type entier.

• Si au moins un des opérandes est réel, le résultat est réel.
 Pour éviter des erreurs de calcul : utiliser des
variables de même type dans un calcul
arithmétique !!
89
Divisions entières et réelles
Division entière : a, b, div, reste sont des entiers

a / b  div, reste avec a= div x b + reste
a b
reste div
Opérateur Modulo (avec des entiers) : reste= a%b
et div= a/b
Exemple : div= 5/2= 2, reste= 5%2= 1 (5= 2x2+1)
Division réelle : a, b, div sont des réels

a / b  div avec a= div x b et div= a/b
Exemple : div= 5 / 2= 2.5
90
Incompatibilités de Types (1)
Le programme doit faire une division réelle
/* Division avec
opérandes entiers et div
résultat réel */ &div 1.0 REEL
ALGO DiviserEntiers
VAR ensc a= 3 Conversion de type
ensc b= 2 1 ENTIER
rsp div
DEBUT / : division Division entière
/* division
entière car les a et b
sont entiers */ 3 2 ENTIERS
div a/b
FIN
91

/* Division avec opérandes
réels et résultat entier */
div
ALGO
DiviserRéelsTronqués &div 1 ENTIER
VAR rsp a= 3. Conversion de type
rsp b= 2. 1.5
ensc div
REEL
DEBUT
/* division réelle car
/ : division Division réelle
les a et b sont réels, mais le
résultat est tronqué lors de
3. 2. REELS
l’affectation dans div */
div  a/b
FIN
92
/* Division avec opérandes

et résultat réels */ div
ALGO DiviserRéels REEL
VAR rsp a= 3.
&div 1.5
rsp b= 2.
1.5
rsp div REEL
DEBUT
/* division réelle / : division Division réelle
car a et b sont réels, puis
affectation dans un réel */
3. 2. REELS
div  a/b
FIN
93
Description des Calculs Binaires
Calculs binaires avec variables en base 10 :

• Opérations : Opérateurs binaires: . (et binaire), + (ou
binaire),  (ou exclusif), - (inverseur).
• Opérandes entiers (base 10 ou 16), résultat entier (base 10).
• Calculs bit à bit au niveau matériel avec valeurs en base 2.
ATTENTION :
 Les calculs se font sur les représentations binaires !!
 Il est nécessaire de passer en base 2 pour vérifier les calculs.
 Mais, dans le programme, on écrit les entiers en base 10.
Il faut faire attention aux nombre de bits

utilisés (au choix du type entier) !! 94
Opérateurs Binaires
Symbole Rôle
a Complément à 1
a a a.b et
0 1 a+b ou
1 0 ab ou exclusif
a b a.b a b a+b a b ab

0 0 0 0 0 0 0 0 0
0 1 0 0 1 1 0 1 1
1 0 0 1 0 1 1 0 1
1 1 1 1 1 1 1 1 0
95
Exemples de Calculs Binaires
// inversion binaire
a inverseur ALGO CalculBinaire1
&a 1 &inverseur 65534 VAR ensc a= 110, inverseur
DEBUT
/* inverseur binaire appliqué
a  00000000 000000012  sur une représentation 2 octets */
11111111 11111110 2  6553410 inverseur= ā
FIN
a b c
// et binaire
ALGO CalculBinaire2 &a 3 &b 2 &c 2
VAR ensc a= 310, b= 210, c a 00000000 00000011
2
DEBUT b 00000000 00000010
/* et binaire appliqué sur 2
des représentations 2 octets */ __________ __________ ________
c 00000000 00000010 2
c= a.b 2 10
FIN 96
MECANISME TYPE : Masquage d’un entier
Le programme doit écraser (forcer à 0, masquer)
l’octet de poids fort d’un ensc.
ALGO Masquage
a 00000011 00000011 VAR ensc masque= 25510, c
2
ensc a= 77110
masque . 00000000 11111111 // 771= 3+256+512
2
__________ __________ ________ DEBUT
/* et binaire pour masquer
c 00000000 00000011  3
2 10 l’octet de poids fort de a */
c= a . masque
FIN
Il faut calculer le masque en base 2 (avec des 0 pour les bits

à masquer), puis écrire le calcul en base 10.
97
Description des Calculs Logiques
Calculs logiques :
• Opérations logique booléenne : ET (et logique), OU (ou
logique), NON (inversion logique).
• Opérations logique de comparaison : < (strictement
inférieur), > (strictement supérieur), ≤ (inférieur ou égal),
≥ (supérieur ou égal), = = (égal), ≠ (différent).
• Opérandes : booléens, entiers, réels, caractères (FAUX vaut
0, VRAI les autres valeurs numériques).
• Résultat : seulement booléen (VRAI ou FAUX).
ATTENTION : = (opérateur d’affectation) et = = (opérateur

de comparaison) ne font pas du tout la même chose !! 98
Opérateurs Logiques
expression1 expression2 expression1 OU expression2

FAUX FAUX FAUX
FAUX VRAI VRAI
VRAI FAUX VRAI
VRAI VRAI VRAI
expression NON(expression)
VRAI FAUX
FAUX VRAI
expression1 expression2 expression1 ET expression2
FAUX FAUX FAUX
FAUX VRAI FAUX
VRAI FAUX FAUX
VRAI VRAI VRAI 99
Exemple de Calculs Logiques
// opérateurs booléens et de comparaison

ALGO CalculLogique
VAR carac car= ‘a’
car
‘a’
rsp reel= 30.
bool logique
reel
30.
DEBUT
logique= NON(car==’a’) OU (reel>30.)
FIN
logique
0
car==‘a’ NON(car==‘a’) reel>30. logique

VRAI FAUX FAUX FAUX
100
Le programme calcule l’expression logique :
NON(car==’a’) OU (reel>30.)
pour différentes valeurs de car et reel.



102
ALGO Nom
DEBUT
// commentaires
instruction 1
instruction 2
…
FIN
 Indentations,
Chapitre E : Alternatives dans un Programme
1- INSTRUCTION ALTERNATIVE SIMPLE
1.1- Instruction SI-ALORS
1.2- Instruction SI-ALORS-SINON
2- INSTRUCTION ALTERNATIVE CHOIX
2.1- Instruction CHOIX-CAS/SORTIR
2.2- Instruction CHOIX-CAS
3- INSTRUCTION ALTERNATIVE COMPLEXE
3.1- Imbrications de SI-ALORS-SINON
3.2- Instruction SI-ALORS-SINON SI
Instruction Alternative SI-ALORS
Rôle: avec l’instruction alternative SI-ALORS, l’exécution

d’un bloc d’instructions dépend de la valeur d’une condition
logique (la condition logique joue le rôle d’un filtre).
Instruction : SI (condition logique) ALORS

bloc d’instructions
(partie instruction) FSI
Exécution par le CPU: si la condition logique est

VRAIE, le bloc d’instructions est exécuté ; sinon, le CPU
passe après la fin de SI.
105
Organigramme du SI-ALORS
FAUX
condition logique ?
VRAI
Bloc d’instructions
Suite du programme
106
Exécution de l’Instruction SI-ALORS
Simulation exécution 1:
INSTRUCTION PROCESSEUR
1- SI évaluation condition logique : VRAI
2- ALORS exécution bloc d’instructions
3- FSI suite du programme après la fin du SI
1- SI évaluation condition logique : FAUX

107
MECANISME TYPE : Mise à jour sélective de variable
Le programme calcule le prix d’un achat (prix unitaire 10F);

une remise de 20% est accordée au-delà de 10 articles.
ALGO Achats
CONST rsp PRIXUNIT= 10, REDUC= 20
VAR rsp prixTotal ; ensc nbArt
DEBUT
Afficher("Nombre d’articles : ") // saisie nombre d’articles achetés
Saisir(&nbArt)
prixTotal= nbArt x PRIXUNIT // calcul du prix sans réduction
SI (nbArt ≥ 10) ALORS // modification du prix si une remise est accordée
prixTotal= prixTotal x (1-REDUC/100)
FSI
Afficher("Prix a payer : ",prixTotal) // affichage du prix à payer
FIN 108
MECANISME TYPE : Mise à jour sélective de variable
Mise à jour sélective de variable :
 La variable est mise à jour dans le cas approprié

(dans le ALORS) : sa valeur est modifiée.
 En cas de non passage dans le SI, la variable a la

valeur de l’initialisation (calculée avant le
passage dans le SI).
109
Instruction Alternative SI-ALORS-SINON
Rôle: avec l’instruction alternative SI-ALORS-SINON, le

choix entre deux blocs d’instructions dépend de la valeur
d’une condition logique (qui joue le rôle d’un aiguillage).
Instruction : SI (condition logique) ALORS

bloc d’instructions 1
(partie instruction) SINON
FSINON
Exécution par le CPU: si la condition logique est
VRAIE, le bloc d’instructions 1 du ALORS est exécuté ; si
elle est FAUSSE, le CPU exécute le bloc 2 du SINON.
110
Organigramme du SI-ALORS-SINON
FAUX
condition logique ?
VRAI
Bloc d’instructions 1 Bloc d’instructions 2
Suite du programme
111
Exécution de l’Instruction SI-ALORS-SINON
1- SI évaluation condition logique : VRAI

2- ALORS exécution bloc d’instructions 1
1- SI évaluation condition logique : FAUX

2- SINON exécution bloc d’instructions 2
3- FSINON suite du programme après la fin du SI
112
MECANISME TYPE : Protection des Calculs
Le programme effectue la division de 2 réels saisis au clavier.
ALGO Division
VAR rsp a, b, div
DEBUT
Afficher("Donnez 2 reels : ") ; Saisir(&a,&b) // saisie des réels
SI (b ≠ 0) ALORS // protection division par 0 condition VRAIE : b ≠ 0
div= a/b // division possible
Afficher("Resultat : ",div)
SINON // condition VRAIE : b = = 0
Afficher("Erreur: diviseur nul !!") // division impossible
FSINON
FIN
113
MECANISME TYPE : Protection des Calculs
Protection des calculs :
Le programmeur doit toujours penser à protéger

les calculs pour éviter que son programme ne
"plante" brusquement.
114
Division de réels : Exécution par le CPU (1)
Instruction Processeur Mémoire
1-Déclaration Réservation &resu resu &a a &b b

variables mémoire
attente,
conversion, &a a b
2- Saisies 5 .2 &b
affectation 0 .0
3- SI Evaluation
(b0.): FAUX
4-SINON: Erreur
Afficher(“Erreur”)
5- FSINON : FIN
115
Division de réels : Exécution par le CPU (2)
&resu resu &a a b

1- Déclaration Réservation
variables &b
mémoire
2- Saisies attente,
conversion, &a a b
5.0 &b
affectation 2.0
Evaluation
3- SI
(b0.): VRAI
4- ALORS: - calcul: 5./2. & re s u resu

- affectation 2 .5
resu= a/b
5- Afficher(resu) 2.5
116
Exemple d’utilisation du SI-ALORS-SINON
Le programme calcule un prix achat avec remise éventuelle.
ALGO Achats
CONST rsp PRIXUNIT= 10, REDUC= 20
VAR rsp prixTotal ; ensc nbArt
DEBUT
Afficher("Nombre d’articles : ") ; Saisir(&nbArt) // saisie nb article
SI (nbArt ≥ 10) ALORS /*calcul du prix avec ou sans réduction
condition VRAIE : nbArt ≥ 10 */
prixTotal= nbArt x PRIXUNIT x (1-REDUC/100)
SINON // condition VRAIE : nbArt < 10
prixTotal= nbArt x PRIXUNIT
FSINON
Afficher("Prix a payer : ",prixTotal) // affichage du prix à payer
FIN 117
Instruction Alternative CHOIX-CAS/SORTIR
Rôle: L’instruction alternative CHOIX-CAS/SORTIR est

un aiguillage : choix du cas à exécuter en fonction de la
valeur d’une variable de type entier ou caractère.
CHOIX (nomVariable)
Instruction : CAS valeur 1: bloc d’instructions 1
SORTIR
CAS valeur 2: bloc d’instructions 2
(partie instruction) SORTIR
...
DEFAUT: bloc d’instructions3
FCHOIX
118
Exécution d’une Instruction CHOIX-CAS/SORTIR

1. Le CPU compare successivement
le contenu de nomVariable aux
valeurs des différents CAS, de
CHOIX (nomVariable)
CAS valeur 1: bloc 1 haut en bas.
SORTIR
CAS valeur 2: bloc 2 2. Dès qu’une égalité est VRAIE, le
SORTIR CPU exécute le bloc associé.
...
DEFAUT: bloc 3 3. Arrivé au SORTIR, le CPU sort
FCHOIX de l’instruction CHOIX.
4. Si aucune égalité n’est VRAIE,

le CPU exécute le cas par
DEFAUT (optionnel).
119
Illustration de l’Exécution du CHOIX-CAS/SORTIR
Bloc 1
Lecture Égale
nomVariable Bloc 2
valeur2
Bloc 3
120
Organigramme du CHOIX-CAS/SORTIR
VRAI
nomVariable== valeur 1?? Bloc 1
FAUX
nomVariable== valeur 2?? VRAI Bloc 2
...
FAUX DEFAUT
Bloc 3
Suite du programme
121
Exécution de l’Instruction CHOIX-CAS/SORTIR
1- CHOIX(nomVariable) lecture valeur de nomVariable
2- CAS valeur 1 nomVariable = = valeur 1 ? : VRAI
3- bloc 1 exécution bloc d’instructions 1
4- SORTIR suite du programme après la fin du CHOIX
1- CHOIX(nomVariable) lecture valeur de nomVariable
2- CAS valeur 1 nomVariable = = valeur 1 ? : FAUX
3- CAS valeur 2 nomVariable = = valeur 2 ? : FAUX
4- DEFAUT exécution bloc d’instructions 3
5- SORTIR suite du programme après la fin du CHOIX
122
MECANISME TYPE : Gestion d’un Menu
Le programme simule une calculatrice à 2 opérations.
ALGO Calculatrice
VAR rsp a, b, resu
carac choixMenu
DEBUT // saisie choix menu et des opérandes
Afficher("a) +, b) - ") ; Saisir(&choixMenu) ; Saisir(&a,&b)
CHOIX (choixMenu) // aiguillage vers les options du programme
CAS ‘a’: resu= a+b // option addition
SORTIR
CAS ‘b’: resu= a-b // option soustraction
FCHOIX
Afficher("Resultat de l’opération : ",resu)
FIN
123
MECANISME TYPE : Gestion d’un Menu
 L’instruction CHOIX-CAS/SORTIR
permet d’aiguiller vers différentes
options de menu exclusives.
 Chaque option peut être différenciée par
une valeur caractère (ou entière).
 Un cas par défaut peut traiter un
mauvais choix de l’utilisateur.
 Le dernier SORTIR n’est pas
obligatoire.
124
Gestion d’un Menu : Exécution par le CPU
&resu resu &a a

1- Déclarations Réservations
mémoire &choixMenu
choixMenu
&b b
- attente & choixMenu

choixMenu
2-Saisies - conversion ‘a’
choixMenu, a, b - affectation &a a &b b
1. 2.
choixMenu==‘a’
3- CHOIX,CAS ‘a’
: VRAI
-calcul: 1.+2.
resu
4- resu= a+b - affectation &resu
3.
5- SORTIR : va à FCHOIX
6- Afficher(resu) 3
125
Utilisation de CHOIX-CAS
!! Attention, l’oubli de SORTIR change l’exécution

par le CPU !!
CHOIX (nomVariable)
...
DEFAUT: bloc d’instructions3
FCHOIX
Exécution par le CPU : le CPU ne sort pas du choix

après l’exécution d’un cas, mais exécute les
instructions des CAS suivants.
126
Organigramme du CHOIX-CAS
VRAI
FAUX
VRAI
...
FAUX DEFAUT
Bloc 3
Suite du programme
Le CAS, dont la valeur est égale à la variable, est un point

d’entrée dans les instructions du CHOIX. 127
Exemple d’utilisation de CHOIX-CAS
ALGO Calculatrice
VAR rsp a, b, resu
carac choixMenu
DEBUT // saisie choix menu et des opérandes
Afficher("a) +, b) - ") ; Saisir(&choixMenu) ; Saisir(&a,&b)
CAS ‘a’: resu= a+b // option addition
// PAS DE SORTIR !!
FCHOIX
FIN
128
Exemple d’imbrication de SI-ALORS-SINON
SI (condition logique 1) ALORS
SINON
FSINON (3)
SINON
FSINON (2)
SINON
FSINON (1)
condition 1 condition 2 condition 3
Exécution de bloc 1 si : V V V
Exécution de bloc 2 si : V V F
Exécution de bloc 3 si : V F --
Exécution de bloc 4 si : F -- 129 --
MECANISME TYPE : Découpage d’intervalles
Le programme affiche les mentions à un examen.
note [0 Refus [10 Passable [12 AB [14 B [16 TB 20]
SI (note < 10) ALORS
Afficher("Refus") // note<10
SINON // note≥10
Afficher("Passable") // note≥10 et note<12
SINON // note≥10 et note≥12  note≥12
SI (note < 14) ALORS // note≥12 et note<14
Afficher("AB")
SINON c note≥12 et note≥14  note≥14
SI (note < 16) ALORS // note≥14 et note<16
Afficher("B")
SINON // note≥14 et note≥16  note≥16
Afficher("TB")
FSINON
FSINON
FSINON
FSINON 130
Il faut bien regarder les conditions

logiques qui sont VRAIES dans les
différents ALORS ou SINON.
131
Instruction Alternative SI-ALORS-SINON SI
Rôle: L’instruction alternative SI-ALORS-SINON SI permet

d’aiguiller sur un nombre quelconque de blocs d’instructions, en
fonction de conditions logiques.
bloc 1
Instruction :
SINON SI (condition logique 2) ALORS
(partie instruction) bloc 2
SINON SI (condition logique 3) ALORS
bloc 3
SINON
bloc 4
FSI
132
Exécution d’une Instruction SI-ALORS-SINON SI (1)

1. Le CPU évalue successivement
les conditions logiques des SI,
SI (condition 1) ALORS
de haut en bas.
bloc 1
SINON SI (condition 2) 2. Dès qu’une condition est
bloc 2 VRAIE, le CPU exécute le
SINON SI (condition 3) bloc associé.
bloc 3
SINON 3. A la fin de l’exécution d’un
bloc 4 bloc, le CPU sort de
FSI l’instruction.
4. Si aucune condition n’est
VRAIE, le CPU exécute le
dernier SINON (optionnel).
133
Exécution d’une Instruction SI-ALORS-SINON SI (2)
SI (condition 1) ALORS
bloc 1
SINON SI (condition 2) ALORS Un SINON SI exclu
bloc 2 tous les SI précédents
SINON SI (condition 3) ALORS (conditions logiques
bloc 3 inversées).
SINON
bloc 4
FSI
condition 1 condition 2 condition 3

Exécution de bloc 1 si : V -- --
Exécution de bloc 2 si : F V --
Exécution de bloc 3 si : F F V
Exécution de bloc 4 si : F F F 134
Organigramme du SI-ALORS-SINON SI
VRAI
condition logique 1? Bloc 1
FAUX
VRAI
condition logique 2 ? Bloc 2
FAUX
VRAI
condition logique 3 ? Bloc 3
...
FAUX SINON
Bloc 4
Suite du programme135
Le programme affiche les mentions à un examen.
note [0 Refus [10 Passable [12 AB [14 B [16 TB 20]

Afficher("Refus") // note<10
SINON SI (note < 12) // note≥10 et note<12
Afficher("Passable")
SINON SI (note < 14) // note≥10, note≥12, note<14  14>note≥12
Afficher("AB")
SINON SI (note < 16) // note≥12, note≥14, note<16  16>note≥14
Afficher("B")
SINON Afficher("TB") // note≥14, note≥16  note≥16
FSI
136
Il faut bien regarder les conditions

logiques qui sont VRAIES dans les
différents SINON SI.
137
MECANISME TYPE : Enumération de cas discrets
Le programme reproduit les cas suivants :
SI (b≠0) ALORS
Afficher("1") // b≠0
b≠0 b= =0 SINON SI (c= =0) ALORS //b = =0 et c= =0
c= =0 c≠0 Afficher("2")
1 SINON // b= =0 et c≠0
2 3 Afficher("3")
FSINON
SI (b≠0) ALORS
Afficher("1") // b≠0
SINON // b= =0
SI (c= =0) ALORS
Afficher("2") // b= =0 et c= =0
SINON // b= =0 et c≠0
Afficher("3")
FSINON
FSINON 138


139
ALGO Nom
DEBUT
// commentaires
instruction 1
instruction 2
…
FIN
 Indentations,
0X2=0
Afficher la table de multiplication par 2 : 1X2=2
2X2=4
ALGO TableMultiplication1 .
VAR ensc produit 10 X 2 = 20
DEBUT
produit= 0x2
Afficher(“0 X 2 = ”,produit)
produit= 1x2
Afficher(“1 X 2 = ”,produit)
… 11 fois ... !!
FIN
Code plus synthétique: produit= ix2

Instructions à faire 11 fois: Afficher(i,“ X 2 = ”,produit)
i commence à 0 et finit à 10
141
Chapitre F : Itérations dans un Programme
1- DESCRIPTION DES BOUCLES
1.1- Instruction POUR
1.2- Instruction TANTQUE
2- ECRITURE d’un POUR ou d’un TANQUE

2.1- Analogie POUR/TANTQUE
2.2- Comment écrire les boucles ?
3- DES MECANISMES TYPES
3.1- Boucles avec Conditions simples
3.2- Boucles avec Conditions complexes
Instruction Itérative POUR
Rôle: L’instruction itérative POUR répète l’exécution d’un

bloc d’instructions un nombre connu de fois (boucle avec
compteur).
POUR i de valInit à valFin, PAS de x
Instruction : bloc d’instructions
FPOUR
(partie instruction)
Exécution par le CPU: le CPU recommence l’exécution

du bloc d’instructions tant que la variable compteur i ne
dépasse pas valFin. Le compteur démarre, la première fois,
à valInit et est incrémenté de x à chaque reprise de boucle.
143
Précisions sur la Boucle POUR
Le PAS x, incrément entre 2 exécutions de la boucle POUR,

est positif (comptage, sens croissant) ou négatif (décomptage,
sens décroissant). Il est optionnel, s’il vaut +1.
La variable compteur (ou variable de boucle) i est

obligatoirement de type entier.
Si la condition de poursuite de boucle est VRAIE (i ne

dépasse pas valFin), la boucle continue.
Si la condition de fin de boucle est VRAIE (i dépasse

valFin), la boucle s’arrête.
Condition de poursuite = NON(Condition de fin) :

conditions logiques inverses 144
Organigramme du POUR
i = valInit
FAUX
i dépasse valFin ?
VRAI
i = i+ x
Suite du programme
145
Précisions sur le sens de comptage
Suivant le signe du pas, attention aux valeurs init et fin.
Comptage : pas x > 0 Décomptage : pas x < 0

• valInit ≤ valFin (croissant) • valInit ≥ valFin (décroissant)
[valInit i valFin] [valFin i valInit]
Condition de poursuite de Boucle :

i ≤ valFin i ≥ valFin
Condition de fin de Boucle :
i > valFin i < valFin
POUR i de 1 à 10, PAS de 2 POUR i de 50 à 47, PAS de -1
i= {1,3,5,7,9} i= {50,49,48,47} 146

Exécution de l’Instruction POUR (sens croissant)
1- POUR a- initialisation : i= valeurInit
b- test fin de boucle : i > valeurFin (FAUX)
2- DANS LE POUR exécution bloc d’instructions

3- FPOUR : POUR (automatique)
a- incrémentation : i= i + x
b- test fin de boucle : i > valeurFin (FAUX)
4- DANS LE POUR exécution bloc d’instructions
5- FPOUR : POUR (automatique)
a- incrémentation : i= i + x
b- test fin de boucle : i > valeurFin (VRAI)
6- FPOUR suite du programme après la fin du POUR
147
Exemple d’utilisation du POUR
Le programme affiche la table de multiplication par 2.
ALGO TableMultiplication2
VAR ensc produit, i
DEBUT
// parcours des valeurs à multiplier
POUR i de 0 à 10, pas de 1
// calcul et affichage des produits
produit= i x 2
Afficher(i," x 2 = ",produit)
FPOUR
FIN
148
Table de multiplication 2 : Exécution par le CPU
1- Déclaration variables Réservation &produit produit &i i
mémoire
2- POUR a- initialisation i
&i
i= 0 0
b- test poursuite boucle
0  10 : VRAI
3- DANS LE POUR : a- calcul: 0x2 &produit
produit
-produit= ix2 b- affectation 0 0X2=0
-Afficher(i,"x2=",produit) RC c- affichage -
i
4- FPOUR : POUR a- incrémentation &i
1
i= i + 1
b- test poursuite boucle 0X2=0
1  10 : VRAI . 2=2
1X
… … … .
4- FPOUR : POUR a- incrémentation i 10 X 2 = 20
&i
i= i + 1 11
b- test poursuite boucle
11  10 : FAUX
5- FPOUR suite après FPOUR
149
Instruction Itérative TANT QUE
Rôle: L’instruction itérative TANT QUE répète

l’exécution d’un bloc d’instructions tant qu’une condition
est vraie (boucle conditionnelle).
FAIRE
Instruction :
(partie instruction) TANTQUE (condition de poursuite)
TANTQUE (condition de poursuite)
FTANTQUE
Exécution par le CPU: le CPU recommence l’exécution

du bloc d’instructions tant que la condition de poursuite
est VRAIE. Dès que la condition de fin est VRAIE, la boucle s’arrête.
150
Organigramme des TANT QUE
FAIRE-TANT QUE TANT QUE-FAIRE
Bloc d’instructions FAUX

Condition
poursuite ?
VRAI Condition VRAI

poursuite ?
FAUX
Suite du programme
Suite du programme
151
Exécution de l’Instruction FAIRE-TANT QUE
1- FAIRE exécution bloc d’instructions
2- TANTQUE évaluation condition logique de poursuite : VRAI
6- TANTQUE évaluation condition logique de poursuite : FAUX
7- suite du programme après la fin du TANTQUE
152
Exécution de l’Instruction TANT QUE-FAIRE
2- bloc exécution bloc d’instructions
4- bloc exécution bloc d’instructions
5- TANTQUE évaluation condition logique de poursuite : FAUX
6- suite du programme après la fin du TANTQUE
153
Exemple d’utilisation du FAIRE-TANT QUE
Le programme affiche la table de multiplication par 2.
ALGO TableMultiplication3
VAR ensc produit, i
DEBUT
i= 0 // initialisation du parcours des valeurs à multiplier
FAIRE
// calcul et affichage des produits
produit= i x 2
Afficher(i," x 2 = ",produit)
i= i+1 // incrémentation des valeurs à multiplier
// condition de poursuite : (i < 11) et condition de fin : (i ≥ 11)
TANT QUE (i < 11)
FIN 154
Table de multiplication 3 : Exécution par le CPU
Réservation
1- Déclaration variables &produit produit &i i
mémoire
2- Initialisation : i= 0 affectation &i 0 i
3- FAIRE a- calcul: 0x2 produit
&produit
-produit= ix2 b- affectation 0
-Afficher(i,"x2=",produit) c- affichage &i
i 0X2=0
-i= i+1 d- calcul: 0+1 1 -
e- affectation
4- TANTQUE évaluation condition poursuite 1<11: VRAI
produit
5- FAIRE a- calcul: 1x2 &produit
2
-produit= ix2 b- affectation 0X2=0
1X2=2
-Afficher(i,"x2=",produit)RC c- affichage i -
-i= i+1 d- calcul: 1+1 &i
2
e- affectation 0X2=0
… … …
1X2=2
6- TANTQUE évaluation condition poursuite 11<11: FAUX .
10 X 2 = 20
7- suite après TANTQUE 155
POUR : Cas particulier du TANT QUE
Une boucle POUR peut toujours être transformée en
boucle TANT QUE.
La boucle TANT QUE est plus générale ; elle permet de faire
plus de choses.
POUR i de 1 à 5 pas de 1
i= 1
Afficher(i) TANTQUE (i ≤ 5)
FPOUR Afficher(i)
i= i+1
i= 1 FTANTQUE
FAIRE
Afficher(i)
i= i+1
TANTQUE (i ≤ 5)
156
Quand utiliser une boucle POUR ou TANT QUE ?
NON
Traitement à répéter
plusieurs fois ? Pas de boucle
OUI
Choix d’une boucle
NON
Le programmeur sait combien de
fois la boucle tourne ?
Boucle TANT QUE avec

OUI condition logique
Boucle POUR avec compteur

157
Comment écrire une Boucle POUR ?
Décomposer le problème, à partir
d’exemples, pour trouver les
instructions qui se répètent
CONTENU de la boucle
FIXER VALEURS de DEMARRAGE et de FIN de comptage
FIXER le PAS de comptage
Ecrire la boucle POUR
Vérifier la boucle POUR :

Dérouler l’exécution avec les valeurs
limites et un cas standard
158
Comment écrire une Boucle TANT QUE ?
Décomposer le problème, à partir
d’exemples, pour trouver les
instructions qui se répètent
CONTENU de la boucle
TROUVER la CONDITION de POURSUITE de boucle

(si vous trouvez la condition de fin : l’inverser)
Éventuellement, FIXER initialisation et incrémentation
Ecrire la boucle TANT QUE
Vérifier la boucle TANT QUE :

Dérouler l’exécution avec les valeurs
limites et un cas standard 159
MECANISME TYPE : Gestion d’un Menu avec reprise
ALGO Calculatrice
VAR rsp a, b, resu ; carac choixMenu
DEBUT
FAIRE // saisie choix menu et des opérandes
Afficher("a) +, b) -, c) SORTIR"); Saisir(&choixMenu); Saisir(&a,&b)
CAS ‘a’: resu= a+b ; SORTIR // option addition
FCHOIX
// reprise du programme tant que l’utilisateur ne veut pas sortir
TANT QUE (choixMenu ≠ ‘c’)
FIN 160
MECANISME TYPE : Gestion d’un Menu avec reprise
La boucle de reprise du programme permet

d’éviter d’avoir à relancer le programme
(RUN) pour une nouvelle exécution.
161
MECANISME TYPE : Mémoire Tampon (1)
Le programme calcule le PGCD de 2 entiers, avec :
PGCD(a,b)= PGCD(max(a,b)-min(a,b),min(a,b))= ...= PGCD(x,x)= x
x= a
y= b
xTemp = max(x,y) - min(x,y)
x? = max(x,y) - min(x,y)
y = min(x,y)
? = min(x,y)
x= xTemp
Il peut être utile de mémoriser temporairement une quantité

dans une variable au cours de l’exécution d’une boucle.
162
MECANISME TYPE : Mémoire Tampon (2)
Le programme calcule le PGCD de 2 entiers, avec :
PGCD(a,b)= PGCD(max(a,b)-min(a,b),min(a,b))= ...= PGCD(x,x)= x
ALGO PGCD
VAR ensc a, b, x, y, xtemp
DEBUT
Afficher("Donner a et b : "); Saisir(&a,&b) // saisie des 2 entiers
x= a ; y= b // initialisation de x et y pour le calcul du PGCD
FAIRE
xTemp= max(x,y) – min(x,y)
y= min(x,y)
x= xTemp
TANT QUE (x ≠ y) // reprise calcul tant que le PGCD n’a pas été trouvé
Afficher("PGCD : ",x) // affichage du PGCD
FIN
163
MECANISME TYPE : Calcul Cumulatif
Le programme saisit au clavier et additionne 4 entiers.
ALGO SommeCumulée
VAR esc a, somme, i
DEBUT
somme= 0 // initialisation de la somme, alors premier cumul: 0+ 1° entier
POUR i de 1 à 4 // parcours de saisie des 4 entiers
Afficher("Donner un entier : "); Saisir(&a) // saisie d’un entier
somme= somme + a // à chaque passage: cumul de a+valeur précédente
FPOUR
Afficher("somme : ",somme) // affichage de la somme des 4 entiers
FIN
Une boucle qui tourne peut permettre de cumuler des

quantités dans une même variable. La valeur de cette
variable est mise à jour à chaque passage dans la boucle :
la valeur précédente est écrasée par la nouvelle valeur.
164
MECANISME TYPE : Détection de valeur (principe)
4 entiers sont saisis au clavier ; 1 seul ou aucun des nombres
est nul. Il faut détecter, pendant la saisie, la saisie qui
correspond au 0.
 Une recherche de valeur consiste souvent

en une boucle qui scanne des valeurs et
doit détecter la valeur cherchée.
 Il peut être utile de mémoriser la valeur

cherchée pour une utilisation ultérieure.
165
MECANISME TYPE : Détection de valeur (analyse)
Saisir(&entier[0])
i=0
SI entier[0]==0 SI entier[0] ≠0
Mémoriser i=0
Saisir(&entier[1])
i=1
SI entier[1 ]≠0
SI entier[1]==0
Mémoriser i=1
Saisir(&entier[2])
i=2
SI entier[2 ]≠0
SI entier[2]==0
Mémoriser i=2 Saisir(&entier[3]) i=3
SI entier[3]==0 SI entier[3]≠0
Mémoriser i=3
arrêter saisies arrêter saisies i=4
166
Afficher résultat
MECANISME TYPE : Détection de valeur (boucle)
1.Instructions qui se répètent :

Saisir(&entier[i])
SI (entier[i]==0) ALORS
Mémoriser i
SINON
i= i + 1
FSINON
2.Condition de fin de boucle : (entier[i] = = 0) OU (i ≥ 4)
Condition de poursuite de boucle : (entier[i] ≠ 0) ET (i < 4)
3.Initialisation : i commence à 0
167
MECANISME TYPE : Détection de valeur (algorithme)
ALGO DétectionZero
VAR ensc i, entier, zero
DEBUT
i= 0
FAIRE
Saisir(&entier) // détection de l’entier
SI (entier = = 0) ALORS
zero= i // détection saisie nulle
SINON
i= i + 1 // passage à la saisie suivante
FSINON
TANTQUE ( (entier ≠ 0) ET (i < 4) ) // sort si saisie nulle OU i vaut 4
SI ( i = = 4) ALORS // affichage du résultat de la recherche
Afficher("pas trouvé !") // 4 saisies ont été faites sans 0
SINON
Afficher("numéro :",zero) // le 0 trouvé en position zero
FSINON
FIN 168
MECANISME TYPE : Détection de valeur (remarques)
On peut éviter ici la mémorisation de l’indice et afficher

directement la valeur trouvée dans la boucle.
Vérification du programme avec un Jeux de Tests complet:
0 1 2 3
1 0 2 3
1 2 0 3
1 2 3 0
1 2 3 4
169
Chapitre G : Tableaux dans un Programme
1- CREATION DE TABLEAUX
1.1- Déclaration
1.2- Remplissage
2- UTILISATION DE TABLEAUX
2.1- Affichage
2.2- Calculs
Ce qu’est un tableau
Tableau : suite de cases mémoires permettant de

stocker les éléments du tableau, qui sont des données
de même type simple.
Un tableau à une dimension est un vecteur : les cases

sont alignées en une ligne ou en une colonne.
Exemple : tableau de 3 cases contenant des ensc

2 octets 2 octets 2 octets
cases stockant les éléments du tableau
2 5 4 = conteneurs mémoire correspondant
à des données de type simple
6 octets
171
Manipuler un tableau
tab[0]
&tab[0] 2
Nom des cases Donnée de type simple
du tableau
tab[0] tab[1] tab[2]
tab 2 5 4
Indices relatifs
Nom du tableau 0 1 2
des cases du
tableau
tab[0]
&tab[0] 2
tab[1] RAM
&tab[1] 5
tab[2]
&tab[2] 4
Adresses des cases du tableau 172

Instruction de Déclaration de Tableau
Rôle: l’instruction de déclaration de tableau indique les

tableaux où le programme stocke des données de type simple.
Instruction (partie donnée) :

VAR type nomVarTableau[nombre de cases]
vide de longueur: nombre de cases X longueur type.
ALGO DéclarerTableau
Règle de programmation : // partie déclaration des données
Noms significatifs, pas trop long VAR esl tabMesures[100]
Préfixe « tab » rdp tabNotes[50]
DEBUT // instructions
FIN 173
Initialisation d’un Tableau dans la partie Donnée
Dans la partie Données exclusivement, lors de la

Déclaration du tableau, il est possible d’attribuer une valeur à
chaque case du tableau par affectation :
ALGO InitialiserTableau
// lors de la déclaration, dans la partie données
VAR esl tabMesures[10]= {-2, 6, 100, -50, 0, 0, 1, 8, 45, -42}
rdp tabNotes[5]= {10.5, 20, 5, 14.5, 18}
DEBUT
FIN
tabMesures -2 6 100 -50 0 0 1 8 45 -42
tabNotes 10.5 20 5 14.5 18

174
Initialisation d’un Tableau d’un tableau à une dimension
Déclaration avec constante :

CONST ensc NBELT= 5
VAR ensc tabEntier[NBELT]
Initialisation dans la partie instructions :

POUR i de 0 à (NBELT - 1)
tabEntier[i]= 0
FPOUR
Initialisation par saisies clavier :

Afficher ("Elément d’indice ",i, ": ")
Saisir(&tabEntier[i])
FPOUR
175
Initialisation d’un Tableau à 2 dimensions
Déclaration avec constantes :
CONST ensc NBC= 3, NBL=2
VAR ensc tabEntier[NBC][NBL]
Initialisation dans la partie instructions :
POUR i de 0 à (NBL - 1)
POUR j de 0 à (NBC - 1)
tabEntier[i][j]= 0
FPOUR
FPOUR
Initialisation par saisies clavier :
Afficher ("Elément d’indice ",i,j, ": ")
Saisir(&tabEntier[i][j])
FPOUR
FPOUR 176
Boucle d’Affichage
Affichage :
Afficher ("Elément d’indice ",i, ": ",tabEntier[i])
Sauter 1 ligne
FPOUR
tabEntier[0] tabEntier[1] tabEntier[2]

2 5 3
0 1 2
2 5 3
177
Boucle d’Affichage
Affichage :
Afficher ("Elément d’indice ",i,j, ": ",tabEntier[i][j])
FPOUR
Sauter 1 ligne
FPOUR
0 1 2
tabEntier[0][2]
tabEntier[0][0] tabEntier[0][1]
2 5 3
0 1 2
tabEntier[1][2]
tabEntier[1][0] tabEntier[1][1]
7 15 1
2 5 3
7 15 1
178
MECANISME TYPE : Somme Cumulée
Calculs cumulatifs additifs :
sommeCumul= 0
sommeCumul= sommeCumul + tabEntier[i]
FPOUR
Afficher ("Somme cumulée : ",sommeCumul)

1 5 4
0 1 2
sommeCumul
10
0 0+1 1+5 6+4 179
MECANISME TYPE : Produit Cumulé
Calculs cumulatifs produits :
produitCumul= 1
produitCumul= produitCumul x tabEntier[i]
FPOUR
Afficher ("Produit cumulé : ",produitCumul)

1 5 4
0 1 2
produitCumul
20
1 1x1 1x5 5x4
180


181
ALGO Nom
DEBUT
// commentaires
instruction 1
instruction 2
…
FIN
 Indentations,
Chapitre H : Fonctions dans un Programme
1- MISE EN PLACE DE FONCTIONS
1.1- Utilité des Fonctions
1.2- Description des Fonctions
1.3- Exécution des Fonctions par le CPU
1.4- Comment décomposer le Programme en Fonctions ?
2- MISE EN PLACE DES ECHANGES DE DONNEES
2.1- Nécessité des échanges de Données
2.2- Paramètre en Entrée
2.3- Retour en Sortie
2.4- Paramètre en Entrée/Sortie
Des Fonctions pour structurer le Programme (1)
Exemple : ALGO Moyenne5Reels

CONST ensc NBELT= 5
VAR rsp tabReel[NBELT], moy
ensc i
DEBUT
// saisie de 5 réels au clavier
Afficher(“Donnez 5 réels : ”)
Le programme calcule POUR i de 0 à (NBELT-1)

Saisir(&tabReel[i])
la moyenne de 5 réels FPOUR
saisis au clavier. // Affichage du tableau

Afficher(“Les 5 réels saisis sont : ”)
POUR i de 0 à (NBELT-1)
Afficher(tabReel[i])
FPOUR
// Calcul de la moyenne
moy= 0.
moy= moy+tabReel[i]
FPOUR
Afficher(“Moyenne : ”,moy/NBELT)
FIN 184
Des Fonctions pour structurer le Programme (2)
CONST ensc NBELT= 5 ALGO SaisirTableau(rsp tab[NBELT])
/* Remplit un tableau tab[] avec NBELT réels saisis
ALGO Moyenne5Reels au clavier */
VAR rsp tabReel[NBELT], moy VAR ensc i
DEBUT DEBUT
SaisirTableau(tabReel) Afficher(“Donnez”,NBELT, “réels : ”)
AfficherTableau(tabReel) POUR i de 0 à (NBELT-1)
moy= CalculerMoyenne(tabReel) Saisir(&tab[i])
Afficher(“Moyenne : ”,moy) FPOUR
FIN FIN
ALGO AfficherTableau(rsp tab[NBELT])) ALGO rsp CalculerMoyenne(rsp tab[NBELT]))

/* Affiche sur l’écran un tableau tab[] contenant NBELT /* Calcule la moyenne des NBELT contenus
réels */ dans le tableau tab[] */
VAR ensc i VAR rsp somme, resu
DEBUT
ensc i
Afficher(“Les”,NBELT, “réels saisis sont : ”) DEBUT
POUR i de 0 à (NBELT-1) somme= 0.
Afficher(tab[i]) POUR i de 0 à (NBELT-1)
FPOUR somme= somme +tab[i]
FIN FPOUR
resu= somme/NBELT
Structurer le code source en ≠ RETOURNE(resu)
blocs : meilleure lisibilité FIN 185

Des Fonctions pour un Traitement répétitif (1)
ALGO calculatrice CAS ‘c’ : // multiplication
VAR carac choixOp ; rsp a, b FAIRE // Saisie validée des opérandes
DEBUT …
FAIRE // boucle de reprise générale du menu TANT QUE (a>50. OU b>50.)
Afficher (“Menu: ”) ; Saisir(&choixOp) Afficher(“Multiplication : ”,a*b)
CHOIX (choixOp) // traitement du choix SORTIR
CAS ‘a’ : // addition CAS ‘d’ : // division
FAIRE // Saisie validée des opérandes
FAIRE // Saisie validée des opérandes
Afficher(“Donnez les opérandes : ”)
Saisir(&a,&b) …
SI (a>50. OU b>50.) TANT QUE (a>50. OU b>50.)
ALORS Afficher(“Erreur”) SI (b==0.) // protection de la division
FSI ALORS Afficher(“Erreur ”)
TANT QUE (a>50. OU b>50.)
SINON Afficher(“Division : ”,a/b)
Afficher(“Addition : ”,a+b)
SORTIR FSI
CAS ‘b’ : // soustraction SORTIR
FAIRE // Saisie validée des opérandes CAS ‘e’ : // message de fin
Afficher(“Donnez les opérandes : ”) Afficher(“Fin de programme ”)
Saisir(&a,&b) SORTIR
DEFAUT : // erreur de choix dans le menu
SI (a>50. OU b>50.)
Afficher(“Erreur choix ”)
ALORS Afficher(“Erreur”)
FCHOIX
FSI
TANT QUE (choixOp != ’e’)
TANT QUE (a>50. OU b>50.) FIN
Afficher(“Soutraction : ”,a-b)
SORTIR 186
Des Fonctions pour un Traitement répétitif (2)
ALGO calculatrice
VAR carac choixOp ; rsp a, b
DEBUT ALGO SaisirValidée(rsp *ptx, rsp *pty)
FAIRE // boucle de reprise générale du menu /* Cette fonction saisit 2 réels au clavier et
Afficher (“Menu: ”) ; Saisir(&choixOp) valide la saisie (valeurs plus petites ou égales
CHOIX (choixOp) // traitement du choix à 50) */
CAS ‘a’ : // addition DEBUT
SaisirValidée(&a,&b) FAIRE // reprise de saisie si erreur
Afficher(“Addition : ”,a+b) SORTIR Afficher(“Donnez les opérandes : ”)
CAS ‘b’ : // soustraction Saisir(ptx,pty)
SaisirValidée(&a,&b)
//message si une des saisies erronnée
Afficher(“Soutraction : ”,a-b) SORTIR
SI (*ptx>50. OU *pty>50.) ALORS
CAS ‘c’ : // multiplication
Afficher(“Erreur”)
SaisirValidée(&a,&b)
FSI
Afficher(“Produit”,axb) SORTIR
TANT QUE (*ptx>50. OU *pty>50.)
CAS ‘d’: SaisirValidée(&a,&b)
FIN
SI (b==0.) ALORS // protection division
Afficher(“Erreur ”)
SINON
Afficher(a/b)
FSI SORTIR
CAS ‘e’ : Afficher(“Fin programme ”) SORTIR
Rendre le code source
plus court : fonctions
DEFAUT : Afficher(“Erreur choix ”)
FCHOIX
TANT QUE (choixOp != ’e’) réutilisables par appel
187
FIN
Pourquoi utiliser des Fonctions ?
Le programme est plus lisible : on s’y retrouve plus facilement.
Structurer le code source en fonctions distinctes :

– Le programme est décomposé en traitements
(chaque fonction réalise un traitement).
– Chaque fonction a ses propres données locales
(variables/constantes).
Rendre le code source plus court :

– Les traitements répétitifs, qui ne peuvent pas être factorisés,
sont écrits une seule fois dans une fonction.
– Les fonctions sont réutilisables par simple appel.
188
Un Programme est Modulaire
Un programme (écrit dans un langage algorithmique,

exécuté séquentiellement par le CPU) est constitué :
• partie traitement : instructions ;
• partie information : données.
Un programme réalise un ensemble de tâches, décrites
dans le cahier des charges.
Un bon programme est modulaire : il est structuré avec des

fonctions. Chaque fonction réalise une des tâches du
programme et contient ses propres données et instructions.
189
Définition d’une Fonction
Fonction : Traitement simple avec éventuellement des

Entrées/Sorties. La fonction :
 est une suite d’instructions, réalisant une tâche

spécifique,
possède ses propres données, appelées données locales,
est liée aux autres fonctions :
– les appels de fonctions précisent l’ordre d’exécution
des différentes fonctions du programme,
– les échanges de données permettent aux fonctions
de communiquer des informations entre elles.
190
Entrées / Sorties à l’intérieur du Programme
PROGRAMME
Fonction
module de traitement de
E l’information réalisant une tâche S
• Partie instructions Fonction 2

Fonction 1
• Partie données locales
E/S
Fonction 3
191
Algorithme d’une Fonction
E Déclaration donnée échangées en E, S ou E/S

E/S ALGO
-------- NomFonction(-----------)
S déclaration données locales à la fonction
DEBUT
--- commentaires ---
instruction 1
instruction 2
…
FIN
192
Une Fonction en Langage C
--- NomFonction(-----) ; // PROTOTYPE de la Fonction
// Fonction principale
main()
{ --- NomFonction(------); // APPEL de la Fonction

}
// DEFINITION de la Fonction
--- NomFonction(-----)
{ données locales
instructions
} 193
Principe d’exécution
Le CPU commence au début de la fonction principale (main) :

 Il exécute les instruction une par une, dans l’ordre où elles se présentent
(séquentiellement), en suivant leur logique (aiguillage si instruction
alternative, rebouclage si instruction itérative).
Si le CPU rencontre un appel de fonction :

• Il met en attente l’exécution de la fonction principale.
• L’exécution est redirigée vers la fonction appelée ; cette fonction appelée
est exécutée du début à la fin, séquentiellement.
• Lorsque l’exécution de la fonction est terminée, le CPU reprend
l’exécution de la fonction appelante (main() ici) à l’endroit où elle était
arrêtée.
• Arrivé à la fin du main(), il sort du programme.
194
Illustration Graphique de l’exécution
ALGO sous problème P1
ALGO problème P DEBUT
instruction 1
DEBUT
instruction 2
sous problème P1
…
sous problème P2
FIN
…
FIN ALGO sous problème P21
DEBUT
instructions
ALGO sous problème P2 FIN
DEBUT ALGO sous problème P22
sous problème P21 DEBUT
sous problème P22 instructions
FIN FIN
195
Exemple d’exécution : Programme sans Fonction
ALGO Moyenne5Reels
CONST ensc NBELT= 5
ensc i
DEBUT
// saisie de 5 réels au clavier
Afficher(“Donnez 5 réels : ”)
Saisir(&tabReel[i])
FPOUR
// Affichage du tableau
Afficher(“Les 5 réels saisis sont : ”)
Afficher(tabReel[i])
FPOUR
// Calcul de la moyenne
moy= 0.
moy= moy+tabReel[i]
FPOUR
Afficher(“Moyenne : ”,moy/NBELT)
FIN
196
Exemple d’exécution : Programme avec 1 Fonction
ALGO SaisirTableau(rsp tab[NBELT])
CONST ensc NBELT= 5 /* Remplit un tableau tab[] avec NBELT réels
saisis au clavier */
ALGO Moyenne5Reels VAR ensc i
VAR rsp tabReel[NBELT], moy DEBUT
DEBUT Afficher(NBELT, “réels : ”)
SaisirTableau(tabReel)
AfficherTableau(tabReel)
Saisir(&tab[i])
moy= CalculerMoyenne(tabReel)
FPOUR
Afficher(“Moyenne : ”,moy)
FIN
FIN
ALGO rsp CalculerMoyenne(rsp tab[NBELT])
/* Calcule la moyenne des NBELT contenus
dans le tableau tab[] */
ALGO AfficherTableau(rsp tab[NBELT]) VAR rsp somme, resu
/* Affiche sur l’écran un tableau tab[] contenant ensc i
NBELT réels */ DEBUT
VAR ensc i somme= 0.
DEBUT
Afficher(NBELT, “réels saisis sont : ”)
somme= somme +tab[i]
FPOUR
Afficher(tab[i])
resu= somme/NBELT
FPOUR
RETOUR(resu)
FIN 197
FIN
Exemple d’exécution : Fonction appelée plusieurs fois
ALGO calculatrice
VAR carac choixOp ; rsp a, b
DEBUT
FAIRE // boucle de reprise générale du menu
Afficher Menu Saisir(&choixOp)
CHOIX (choixOp) // traitement du choix
CAS ‘a’ : SaisirValidée(&a,&b) ALGO SaisirValidée(rsp *ptx, rsp *pty)
Afficher(“Addition : ”,a+b); SORTIR /* Cette fonction saisit 2 réels au clavier et
CAS ‘b’ : SaisirValidée(&a,&b) valide la saisie (valeurs plus petites ou égales à
Afficher(“Soutraction : ”,a-b) 50) */
SORTIR DEBUT
CAS ‘c’ : SaisirValidée(&a,&b) FAIRE // reprise de saisie si erreur
Afficher(“Produit”,axb) SORTIR Afficher(“Donnez les opérandes : ”)
CAS ‘d’ : SaisirValidée(&a,&b) Saisir(ptx,pty)
SI (b==0.) // protection division //message si une des saisies erronnée
ALORS Afficher(“Erreur ”) SI (*ptx>50. OU *pty>50.)
SINON Afficher(a/b) ALORS Afficher(“Erreur”)
FSI SORTIR FSI
CAS ‘e’ : Afficher(“Fin programme ”); TANT QUE (*ptx>50. OU *pty>50.)
SORTIR FIN
DEFAUT : Afficher(“Erreur choix ”)
FCHOIX
TANT QUE (choixOp != ’e’)
FIN
198
D’où viennent les Fonctions ?
PROBLEME : trouver l’algorithme, même pour

des cahiers de charges très compliqués
METHODE : analyse par approche descendante
RESULTAT : CREATION DE PROGRAMMES

avec des FONCTIONS
199
Méthode d’Analyse par Approche Descendante: Principe
Méthode pour approcher la solution informatique

progressivement par : décomposition d’un problème
complexe en sous problèmes de complexité inférieure
La décomposition progressive en modules élémentaires

permet :
• d’être complet dans l’analyse, Problème P
• de construire la structure
du programme avec des P1 P2  niveau 1
fonctions.
P21 P22  niveau 2

200
Analyse par Approche Descendante: illustration
Problème P
Sous problème P1 Sous problème P2
Sous problème P21 Sous problème P22
201
Un Sous-Problème = un Algorithme
ALGO problème P
DEBUT
sous problème P1
sous problème P2
ALGO sous problème P1 FIN
DEBUT
instructions ALGO sous problème P2
FIN DEBUT
sous problème P21
sous problème P22
FIN
ALGO sous problème P21 ALGO sous problème P22
DEBUT DEBUT
instructions instructions
FIN FIN
202
Méthode d’Analyse par Approche Descendante: Bilan
Part d’un problème initial (cahier des charges)
Arrive à la solution finale (ensemble d’algorithmes

directement traduisibles en C dans des fonctions)
En passant par des niveaux, ou appels, intermédiaires.
203
Un Algorithme = une Fonction
Fonction principale
Fonction 1 Fonction 2
Fonction 21 Fonction 22
204
Exemple d’Analyse par Approche descendante
Le programme calcule la moyenne de 5 réels saisis au clavier.
ALGO Moyenne5Reels
CONST ensc NBELT= 5
DEBUT
// Saisir 5 réels au clavier et les stocker dans le tableau tabReel[]
SaisirTableau(tabReel) // fonction à détailler dans un autre algorithme
// Afficher le contenu du tableau tabReel[] à l’écran
AfficherTableau(tabReel) // fonction à détailler dans un autre algo
// Calculer la moyenne des éléments du tableau tabReel[]
moy= CalculerMoyenne(tabReel) // à détailler dans un autre algo
FIN
Les fonctions apparaissent lors de la décomposition du

cahier des charges en sous problèmes, pendant l’analyse
par approche descendante. 205
Pourquoi échanger des données ? (1)
ALGO Moyenne5Reels ALGO AfficherTableau(----)
CONST ensc NBELT= 5 /* Affiche sur l’écran un tableau tab[] contenant
VAR rsp tabReel[NBELT], moy nbReels réels */
DEBUT
VAR ensc i
SaisirTableau(----)
DEBUT
AfficherTableau(----)
Afficher(nbReels, “réels saisis sont : ”)
----CalculerMoyenne(----)
POUR i de 0 à (nbReels-1)
Afficher(tab[i])
FIN
FPOUR
ALGO SaisirTableau(----) FIN
/* Remplit un tableau tab[] avec nbReels réels
saisis au clavier */ ALGO ----CalculerMoyenne(----)
VAR ensc i /* Calcule la moyenne des nbReels contenus dans
DEBUT le tableau tab[] */
Afficher(nbReels, “réels : ”) VAR rsp somme, resu
POUR i de 0 à (nbReels-1) ensc i
DEBUT
Saisir(&tab[i])
somme= 0.
FPOUR
POUR i de 0 à (nbReels-1)
FIN
somme= somme +tab[i]
FPOUR
Les variables locales ne sont resu= somme/nbReels
connues que dans leur fonction

----
FIN 206
Pourquoi échanger des données ? (2)
Une fonction ne peut pas utiliser les données (variables

et constantes) déclarées dans une autre fonction :
• Les données déclarées dans une fonction sont des données locales.
• Les données locales ne sont visibles que par les instructions de leur
fonction.
• Toute autre fonction ne peut pas les utiliser.
• Les différentes variables locales i dans l’exemple précédent sont des
variables différentes physiquement (un espace mémoire distinct pour
chaque i), même si elles portent le même nom.
Les fonctions doivent donc s’échanger des données, soit

lors de l’appel de la fonction appelée, soit lors du retour
à la fonction appelante :
 Les données échangées sont les paramètres (E et E/S) et les retours de la
fonction (S).
207
Les sens d’échanges de Données
DEBUT fonction 1
instruction 1
instruction 2
E
E/S DEBUT fonction 2
APPEL fonction 2 instruction 4
instruction 5
instruction 3
instruction 6
…
FIN fonction 1 …
S RETOUR fonction 2
Fonction appelante
FIN fonction 2
E/S
Fonction appelée
208
Définition des Paramètres en Entrée d’une Fonction
Paramètre en Entrée d’une Fonction : paramètre

passé par valeur. Le paramètre est en lecture seulement
pour la fonction appelée, qui ne peut pas le modifier.
ALGO Principal
VAR esc n
Instruction : DEBUT
NomFonction(n) //APPEL
FIN
ALGO -- NomFonction(esc x) //DEFINITION

DEBUT ...
FIN
209
Le CPU exécute le passage de Paramètre en Entrée à 1 Fonction

ALGO Principal
VAR esc n
DEBUT
NomFonction(n) //APPEL
FIN
ALGO -- NomFonction(esc x) //DEFINITION

DEBUT ...
FIN
1. Lors de l’appel de la fonction, le CPU redirige l’exécution

vers la fonction.
2. Il commence par initialiser x avec la valeur de n : x= n.
3. Il exécute les instructions de la fonction.
4. Arrivé à la fin de la fonction, le CPU revient exécuter
l’instruction juste après l’appel de la fonction. 210
Précisions sur les Paramètres en Entrée
PARAMETRE en Entrée :
Fonction appelante • Communique de la fonction
APPEL fonction appelante vers la fonction
appelée.
E • La donnée de la fonction
appelante a une valeur qui
est transmise à la fonction
appelée.
Fonction • De retour dans la fonction
appelée appelante, cette valeur ne
peut pas avoir été changée
par la fonction appelée.211
Illustration graphique sur les Paramètres en Entrée
DEBUT FONCTION 1
instruction 1
instruction 2
APPEL: envoi d’un texte
NBB NB
Fonction appelante
DEBUT FONCTION 2
impression des informations
FIN FONCTION 2
Fonction appelée
212
Exemple de Paramètre en Entrée
Le programme calcule le factoriel d’un entier.
ALGO Factoriel
VAR ensc n
DEBUT
Afficher("Donnez n : ") // Saisie du nombre n au clavier
Saisir(&n)
CalculerFacto( n ) // Calcul et affichage du factoriel
FIN
/* Calcule le factoriel du nombre x et affiche le résultat */

ALGO Calculer Facto( ensc x )
// Variables locales éventuelles
VAR ...
DEBUT
…. // instructions de la fonction utilisant la variable x
FIN
213
Mise en place des paramètres en Entrée
Comment écrire une fonction avec un PARAMETRE en Entrée ?
ALGO Factoriel
VAR ensc n 1. Écrire l’algorithme de la fonction
DEBUT principale, y préciser l’appel de
// Saisie du nombre n
Afficher(“Donnez n : ”)
fonction : CalculerFacto().
Saisir(&n)
// Calcul et affichage du factoriel
2. Mettre en place le paramètre en E :
CalculerFacto( n )
FIN
a. Déclarer le paramètre
localement dans la parenthèse de
la fonction appelée : ensc x.
/* Calcule le factoriel du nombre x et affiche
le résultat */
ensc x )
b. Transmettre la valeur dans
ALGO Calculer Facto(
l’appel : valeur de n.
VAR ...
DEBUT 3. Écrire l’algorithme de la fonction
...
appelée avec ses propres variables
FIN
locales et ses instructions.
214
Mise en place des Paramètres en Entrée en Langage C
---- CalculerFacto( unsigned short x );

main()
{ unsigned short n; PARAMETRE
// Saisie du nombre n en Entrée
printf(“Donnez n : ”);
scanf(“%hu”,&n);
// Calcul du factoriel
---- CalculerFacto(n)
}
---- CalculerFacto( unsigned short x )
{/* instructions de calcul du factoriel
utilisant la variable x */
….
} 215
Exécution par le CPU : Factoriel avec Paramètre en E
1. Exécution de la fonction main()
ALGO Factoriel
a. Déclaration et saisie de n : n
VAR ensc n reçoit 3 du clavier
b. Appel de la fonction avec
DEBUT
Afficher(“Donnez n : ”)
Saisir(&n)
passage de la valeur 3 :
// Calcul et affichage du factoriel CalculerFacto(3)
CalculerFacto( n )
FIN 2. Exécution de la fonction appelée
a. Initialisation des paramètres
en Entrée : x= 3
/* Calcule le factoriel du nombre x et affiche le
résultat */
ALGO CalculerFacto( ensc x )
b. Calcul du factoriel
// Variables locales éventuelles c. Affichage du factoriel
VAR ...
DEBUT d. Retour à la fonction main()
...
FIN
3. Suite et fin de l’exécution du
main()
216
Définition des Retours en Sortie d’une Fonction
Retour en Sortie d’une Fonction : résultat de la

fonction. La valeur du résultat de la fonction est transmise à
la fonction appelante, à la fin de l’exécution de la fonction
appelée.
ALGO Principal
VAR ensl facto
Instruction : DEBUT
facto= NomFonction() //APPEL
FIN
ALGO ensl NomFonction() //DEFINITION

VAR ensl factoriel
DEBUT ...
RETOUR(factoriel)
FIN
217
Le CPU exécute un Retour en Sortie d’une Fonction
Exécution par le CPU: ALGO Principal
VAR ensl facto
DEBUT
facto= NomFonction() //APPEL
FIN
ALGO ensl NomFonction() //DEFINITION

VAR ensl factoriel
DEBUT ...
RETOUR(factoriel)
FIN
1. Lors de l’appel, le CPU redirige l’exécution vers la fonction.

3. Arrivé à la fin de la fonction, le CPU renvoie la valeur du résultat
à la fonction appelante, grâce à l’instruction RETOUR.
4. Le CPU revient finir d’exécuter l’appel de la fonction.
5. La variable à gauche du signe d’affectation reçoit la valeur du
résultat de la fonction : facto= factoriel. 218
Précisions sur les Retours en Sortie
RETOUR en Sortie :
Fonction appelante
APPEL fonction • Communique de la fonction
appelée vers la fonction
appelante.
S
• Le résultat de la fonction
appelée a une valeur qui est
transmise à la fonction
Fonction appelante.
appelée • De retour dans la fonction
appelante, un résultat est
récupéré.
219
Illustration graphique sur les Retours en Sortie
DEBUT FONCTION 1
instruction 1
instruction 2
APPEL: demande le numéro du jour
Affiche numéro de jour
instruction 3
FIN FONCTION 1
Fonction appelante
S DEBUT FONCTION 2
calcul le numéro de jour
RETOUR numéro de jour
FIN FONCTION 2
Fonction appelée
220
Exemple de Retour en Sortie
Le programme calcule le factoriel d’un entier.
ALGO Factoriel
VAR ensc n ; ensl facto
DEBUT
Afficher("Donnez n : "); Saisir(&n) // Saisie du nombre n
facto= CalculerFacto( n ) // Calcul du factoriel
Afficher(" Factoriel : ",facto) // affichage du factoriel
FIN
/* Calcule le factoriel du nombre x */
ALGO ensl Calculer Facto( ensc x )
VAR ... ensl factoriel
DEBUT
…. // instructions de la fonction utilisant la variable x
RETOUR(factoriel)
FIN 221
Mise en place des Retours en Sortie
Comment écrire une fonction avec un RETOUR en Sortie ?
1. Écrire l’algorithme de la fonction
principale, y préciser les fonctions
ALGO Factoriel
VAR ensc n ; ensl facto
appelées : CalculerFacto().
DEBUT
2.
Afficher("Donnez n : "); Saisir(&n)
facto= CalculerFacto( n ) Mettre en place le résultat en Sortie :
Afficher(" Factoriel : ",facto) a. Récupérer le résultat du calcul de
FIN
la fonction CalculerFacto() dans
l’appel : facto= .
/* Calcule le factoriel du nombre x */
ALGO ensl Calculer Facto( ensc x ) b. Déclarer la variable de retour
// Variables locales éventuelles localement dans la fonction appelée
VAR ... ensl factoriel et la renvoyer : ensl, ensl factoriel,
DEBUT
RETOUR(factoriel).
…. // instructions de la fonction
RETOUR(factoriel)
FIN 3. Écrire l’algorithme de la fonction
222
Mise en place des Retours en Sortie en Langage C
unsigned long CalculerFacto( unsigned short x );
main()
{ unsigned short n; unsigned long facto;
printf(“Donnez n : ”); scanf(“%hu”,&n); RETOUR
// Calcul, puis affichage du factoriel en Sortie
facto= CalculerFacto(n)
printf(“Factoriel : %lu”,facto);
}
unsigned long CalculerFacto( unsigned short x )
{ unsigned long factoriel;
/* instructions de calcul du factoriel utilisant la
variable x */ ...
return(factoriel);
} 223
Exécution par le CPU : Factoriel avec Retour en Sortie
a. Déclaration et saisie de n : n reçoit 4
ALGO Factoriel
du clavier
VAR ensc n ; ensl facto b. Appel de la fonction avec passage de
DEBUT la valeur 4 : CalculerFacto(4)
Afficher("Donnez n : "); Saisir(&n)
facto= CalculerFacto( n ) 2. Exécution de la fonction appelée
Afficher(" Factoriel : ",facto)
FIN a. Initialisation du paramètre en E : x= 4
b. Calcul du factoriel avec stockage du
/* Calcule le factoriel du nombre x */ résultat dans la variable locale
ALGO ensl Calculer Facto( ensc x ) factoriel
ensl factoriel c. Retour à la fonction main() avec
VAR ...
DEBUT renvoi de la valeur de factoriel : 24
3. Suite de l’exécution du main()

…. // instructions de la fonction
RETOUR(factoriel)
FIN a. Récupération du résultat dans la
variable locale facto : facto= 24
b. Affichage du résultat
c. Fin du main(). 224
Pourquoi les Entrées/Sorties sont nécessaires ?
Calcul de la puissance
ALGO Main()
VAR esc x, y
ensl puis
DEBUT Impossible de renvoyer
plus d’un résultat en Sortie
Afficher(" Donnez x et y : ")
Saisir(&x,&y)
puis= CalculerPuis(x,y)
SI (puis == -1) ALORS
d’une fonction !!
Afficher(" Erreur ")
SINON
Afficher(puis)
Un autre moyen de
FSINON
FIN
ALGO ensl CalculerPuis( esc a, esc b )

récupérer un résultat de la
VAR ensl puissance, codeErreur fonction = paramètre en
DEBUT
SI (a<=0 OU b<=0) ALORS
Entrée/Sortie de la
codeErreur= -1 fonction.
SINON
puissance = pow(a,b)
FSINON
RETOUR(puissance,codeErreur)
FIN 225
Définition des Paramètres en Entrée/Sortie d’une Fonction
Paramètre en Entrée/Sortie d’une Fonction :

paramètre passé par adresse. Le paramètre est en
lecture/écriture pour la fonction appelée, qui peut le
modifier. ALGO Principal
VAR esc n, tab[5]
Instruction: DEBUT
NomFonction(&n,tab) //APPEL
FIN
ALGO -- NomFonction(esc *x, esc tabp[5])
//DEFINITION
DEBUT ...
FIN
226
Le CPU exécute le passage de Paramètre en E/S à 1 Fonction

ALGO Principal
VAR esc n, tab[5]
DEBUT
NomFonction(&n,tab) //APPEL
FIN
ALGO -- NomFonction(esc *x, esc tabp[5])
//DEFINITION
DEBUT ...
FIN
1. Lors de l’appel de la fonction, le CPU redirige l’exécution
vers la fonction.
2. Il commence par initialiser x avec l’adresse de n : x= &n
et tabp avec l’adresse du tableau tab : tabp= tab
4. Arrivé à la fin de la fonction, le CPU revient exécuter
l’instruction juste après l’appel de la fonction. 227
Précisions sur les Paramètres en Entrée/Sortie
PARAMETRE en E/S :
Fonction appelante • La donnée est transmise en
APPEL fonction Entrée et récupérée en Sortie
de la fonction appelée.
E/S
• L’adresse de la donnée est
transmise à la fonction
appelée.
• De retour dans la fonction
Fonction appelante, le contenu de la
appelée variable peut avoir été
changé par la fonction
appelée.
228
Illustration graphique sur les Paramètres en E/S
DEBUT FONCTION 1
instruction 1
instruction 2
APPEL: envoi 10 valeurs
Affiche les 10 valeurs
FIN FONCTION 1
Fonction appelante
DEBUT FONCTION 2
Normalise les 10 valeurs
FIN FONCTION 2
Fonction appelée
229
Passage par Valeur ou par Adresse ? Principe des E/S
Si la fonction appelée ne doit pas modifier la valeur de la

donnée passée en paramètre, il faut choisir un paramètre en E,
c’est-à-dire qu’il faut transmettre la valeur de la donnée :
passage de paramètre par valeur.
Si la fonction appelée doit modifier la valeur de la variable

passée en paramètre, il faut choisir un paramètres en E/S,
c’est-à-dire qu’il faut transmettre l’adresse de la variable :
passage de paramètre par adresse.
Un tableau est toujours passé en E/S (son nom correspond à

l’adresse de la première case du tableau).
Pour passer une variable de type simple en E/S, il faut

transmettre son adresse à la fonction appelée.
230
Passage par Valeur ou par Adresse ? Passage par Valeur
ALGO ensc Calculer Facto(ensc x)
ALGO Main() VAR ensc facto
VAR ensc n, factoriel DEBUT
DEBUT
facto= 1
Afficher(" Donnez n : ")
Saisir(&n) POUR i de 2 à x
factoriel= CalculerFacto( n ) facto= facto * i
Afficher(factoriel) FPOUR
FIN RETOUR(facto)
FIN
@1 n: 410
@3 x: 410
@2 factoriel: ---
24
@4 facto: 24
231
Passage par Adresse : Tableau
CONST ensc NBELT= 2 ALGO void InitTab(rsp tab[NBELT])
ALGO Main() VAR ensc i
VAR rsp tabReel[NBELT] DEBUT
DEBUT POUR i de 0 à (NBELT-1)
InitTab(tabReel) tab[i]= random(51)
AfficherTab(tabReel)
FPOUR
FIN
FIN
tabReel
@1 tabReel[0]: ---
26 @3 tab
tabReel[1]: ---
2
@2
232
Passage par Adresse : Variable de Type simple
ALGO Main()
VAR rsp a /* Calcule la valeur absolue de x */
DEBUT ALGO void Vabs( rsp *x )
Afficher(" Donnez a : ") DEBUT
Saisir(&a) SI (*x<0)
Afficher(a) ALORS *x= -(*x)
Vabs( &a ) FSI
Afficher(a) FIN
FIN
@3 x
&a= @1 *x=
a: -2.5
a: 2.5
233
Mise en place des Paramètres en E/S : Tableau
Comment écrire une fonction avec un PARAMETRE en E/S ?
CONST ensc NBELT= 10

1. Écrire l’algorithme de la fonction
ALGO Main() principale, y préciser la fonction
VAR rsp tabReel[NBELT] appelée : InitTab().
DEBUT
2. Mettre en place le paramètre en E/S :

InitTab(tabReel)
AfficherTab(tabReel)
FIN
localement dans la parenthèse de
la fonction appelée : rsp
tab[NBELT].
ALGO void InitTab( rsp tab[NBELT] )
VAR ensc i
b. Transmettre l’adresse dans
DEBUT l’appel : l’adresse du tableau est
POUR i de 0 à (NBELT-1) tabReel.
tab[i]= random(51)
FPOUR 3. Écrire l’algorithme de la fonction
FIN
234
Mise en place des Paramètres en E/S : simple Variable
Comment écrire une fonction avec un PARAMETRE en E/S ?
ALGO Main() 1. Écrire l’algorithme de la fonction
VAR rsp a principale, y préciser les fonctions
DEBUT
// Saisie du réel a appelées : Vabs().
Afficher("Donnez a : ")
Saisir(&a) 2. Mettre en place le paramètre en E/S :
Afficher(a)
// Calcul de sa valeur absolue
Vabs( &a ) localement dans la parenthèse de
Afficher(a) la fonction appelée :
adresse rsp *x.
FIN
b. Transmettre l’adresse dans

/* Calcule la valeur absolue de x */ l’appel : adresse de a, &a.
ALGO void Vabs( rsp *x )
3.
DEBUT
SI (*x<0)
Écrire l’algorithme de la fonction
ALORS *x= -(*x) appelée ; pour accéder à la valeur
FSI réelle : *x.
FIN
235
Mise en place des Paramètres en E/S en Langage C
const int NBELT=10
void Fonction( short *x , double tab[NBELT] );

main()
{ short n;
double tabReel[NBELT];
Fonction( &n , tabReel )
printf(“Factoriel : %hd”,n); PARAMETRE
en Entrée/Sortie
}
void Fonction( short *x , double tab[NBELT] )

{
*x= 3;
}
236
Exécution par le CPU : Valeur absolue avec Paramètre en E/S

a. Déclaration et saisie de a : a
ALGO Main()
VAR rsp a
DEBUT
// Saisie du réel a
reçoit -3 du clavier
Afficher("Donnez a : ") b. Appel de la fonction avec
Saisir(&a)
passage de l’adresse de a :
Afficher(a)
// Calcul de sa valeur absolue Vabs(&a)
&a )
2.
Vabs(
Afficher(a) Exécution de la fonction appelée
FIN a. Initialisation des paramètres
en E/S : x= &a
/* Calcule la valeur absolue de x */ b. Modification de la valeur de
ALGO void Vabs( rsp *x ) a : *x= -(-3).
c. Retour à la fonction main() :
DEBUT
SI (*x<0)
ALORS *x= -(*x) a vaut 3 maintenant
FSI
FIN 3. Suite et fin de l’exécution du
main() : le contenu de a a été
modifié. 237
Exemple de Fonction avec échanges de Données (1)
Le programme calcule ab pour a et b entiers positifs non nuls.

Le prototype de la fonction est : rdp puissance(ensc a, ensc b)
Le programme calcule 32 et 53.
3
Puissance (a,b)
2 a
ab
5 b puis
Une fonction avec 2 Entrées et 1 Sortie

deux appels de fonction 238
ALGO Main()
VAR rdp p1, p2
DEBUT
p1= Puissance(3,2)
p2= Puissance(5,3)
Afficher(p1,p2) /* Calcule a puissance b */
FIN ALGO rdp Puissance(ensc a, ensc b)
VAR rdp puis
ensc i
DEBUT // a x a x a x a x ... (b fois)
puis= 1
POUR i de 1 à b
puis= puis x a
FPOUR
RETOUR(puis)
FIN
239
Le programme calcule ab pour a et b entiers positifs non nuls.

Le prototype de la fonction est : esc puissance(ensc a, ensc b,
rdp *puis). La fonction détecte si b est nul et renvoie un code
d’erreur en Sortie : 0 si OK, -1 si pas OK.
Le programme principal saisit les entiers au clavier et affiche
le résultat ou un message d’erreur.
Puissance (a,b,*puis)
x a
y b *puis= ab code
&p
Une fonction avec 2 Entrées et 1 Sortie et 1 E/S

Un appel de fonction, qui dépend des saisies claviers.
240
ALGO Main()
VAR rdp p
ensc x, y
esc erreur /* Calcule a puissance b */
DEBUT ALGO esc Puissance(ensc a,
Afficher(" Donnez x et y : ") ensc b, rdp *puis)
Saisir(&x,&y) VAR esc code= 0
erreur= Puissance(x,y,&p) DEBUT
SI (erreur = = -1) ALORS SI (b = = 0) ALORS
Afficher(" Erreur ")
code= -1
SINON
SINON
Afficher(p)
*puis = pow(a,b)
FSINON
FSI
FIN
RETOUR(code)
FIN
241

Cours Algorithmique 1ère Année

Transféré par

Droits d'auteur :

Formats disponibles

Cours Algorithmique 1ère Année

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Algorithmique 1ère Année

Transféré par

Droits d'auteur :

Formats disponibles

Université Cheikh Anta Diop de Dakar

Ecole Supérieure Polytechnique GE

1ère Année DUT EEAIT & L1 GE

Novembre 2022 – Janvier 2023

Prof: M. Salif Sagana FALL

Objectifs du module : Maîtriser la démarche d’élaboration

Compétences professionnelles à acquérir :

Programmes en C pour piloter des équipements :

Commande d’un variateur Pilotage d’appareils de

Ordinateur : Machine électronique,

Ordinateur : système communicant

Informatique : Science du traitement de

La discipline Informatique traite des aspects :

L’Industrie Informatique a décollé après la 2°

Elle vient de loin : Schickard 1623, Falcon 1728

Les grands noms associés : El Khawarizmi, Pascal,

L’Industrie Informatique a décollé après la 2°

Elle vient de loin : Schickard 1623, Falcon 1728

Les grands noms associés : El Khawarizmi, Pascal,

Des progrès technologiques fulgurants, en 30 ans :

CPU 30 000 fois plus rapide

L’Informatique est quasiment incontournable dans

Trouver des infos sur le WEB y faire des achats

Piloter une chaîne de production Superviser un process

Concevoir des circuits électroniques Jouer

Communiquer par e-mail Réaliser un rapport WORD

Connaître l’outil informatique sera de plus en plus

Informatique Réseaux Multimédia Génie

Piloter des équipements

Développer des sites WEB

L’ordinateur n’est pas du tout intelligent :

L’ordinateur est un automate programmable :

Programmation : développement de programme

Le programme doit être écrit dans un langage de

Intelligence Artificielle, Langages Objets,

langages machine: Assembleur, Binaire

Langage C (procédural ou algorithmique) :

Le programme doit calculer le prix de 2 produits

nb2 produit2 à prix2 FCFA

prixTotal= nb1 x prix1 + nb2 x prix2

Informatisation d'une tâche 

1. Mélanger sucre et jaunes Melange= sucre

Programme : Suite d’instructions (partie traitement à

Fichier source Exécutable

1000 0110 0000 0000

Ecrit avec un langage naturel et simple.

Permet de commenter rapidement son code.

Réfléchir d’abord sur papier permet d’avoir une vue

1. Identifier les données (Entrées et Sorties) du traitement.

RECETTE de CUISINE : RECETTE de CUISINE :

Trouver les bonnes

Pour permettre une représentation facile, toutes les étapes d’un

2. Une action est représentée par un rectangle dans lequel est

3. Une condition est schématisée par un losange dans lequel est

4. Le recueil ou la fourniture d’information est schématisé par

Exemple 2: Résolution d’une équation du 2nd degré: ax2+bx+c=0

Algo Trinome // Nom

1. Bien étudier le cahier des charges

3. Traduire la solution dans un langage de programmation