Ce document présente une initiation à l'algorithmique, visant à acquérir des compétences méthodologiques pour résoudre des problèmes informatiques et réaliser des programmes. Il aborde les étapes de résolution de problème, les concepts d'algorithmes, de variables, de types de données, ainsi que les structures de contrôle et de traitement des données. Plusieurs exemples pratiques, tels que la préparation du thé, sont utilisés pour illustrer les notions abordées.

1. Initiation à
l’algorithmique
Janvier 2020

2. Objectif général
Acquérir les bases méthodologiques de la résolution
d'un problème conduisant à la réalisation d'un
programme informatique
2

3. Objectifs opérationnels
• Connaître les étapes de résolution d’un problème
• Stocker et traiter des données simples
• Permettre à un programme de communiquer avec l’extérieur
• Contrôler le flux d’exécution des instructions
• Traiter des données composites
• Définir et utiliser des procédures et des fonctions
3

4. Sommaire
1. Algorithme
2. Étapes de résolution d’un
problème
3. Identificateur
4. Variable
5. Types simples
6. Constante
7. Affectation
8. Opérateurs
9. Entrées/sorties
10. Structures de contrôle
11. Tableaux
12. Sous-programmes
13. Enregistrements
4

5. Algorithme
présentation
• Algorithme :
– du nom du mathématicien persan Al-Khwârizmî
– façon de décrire dans ses moindres détails comment
procéder pour faire quelque chose
– suite finie d’opérations ou d’instructions que l’on
applique à un nombre fini de données pour résoudre
un problème.
• Ex : résolution d’un problème arithmétique, indication
d’un trajet, recette de cuisine, …
• En informatique, l’algorithme est écrit dans un langage
proche du langage humain appelé pseudo langage.
• L’algorithme n'est pas fait pour être exécuté directement
par une machine, mais il a l'avantage d'être traduit
facilement dans tous les langages de programmation.
problème
algorithme
réflexion
programme
traduction
Al-Khwârizmî
Mathématicien persan
(780 – 850)
5

6. Algorithme
exemple : "thé à la sénégalaise"
• Ingrédients : paquet de thé, pot de sucre, bouteille d’eau.
• Résultat : servir des verres de thé.
• Matériel : théière, verres à thé, plateau, fourneau avec du
charbon ardent
• Actions à réaliser
1. Mettre de l’eau dans la théière
2. Mettre du thé dans la théière
3. Poser la théière sur le fourneau
4. Tant que (pas d’ébullition)
laisser la théière sur le fourneau
5. Poser la théière sur le plateau
6. Mettre du sucre dans la théière
7. Appeler Moussa, le « mousseur » de thé
8. Si (le thé est très refroidi) alors
réchauffer le thé
9. Remplir les verres de thé
10. Servir les verres de thé
Sous-algo de Moussa
Moussa reçoit la théière remplie et les verres à
thé posés sur le plateau
pour produire de la mousse dans les verres
7.1. Remplir un verre de thé au 3/4
7.2. Faire
Transvaser ce thé d’un verre à un autre
Tant que (Il y a un verre sans mousse)
6

7. Algorithme
structure(1/2)
• Un algorithme est composé d’une entête et d’un corps
• Dans l'entête :
– nom (obligatoire) de l'algo annoncé par « Programme »
– définition de types annoncée par « Type » ;
– déclaration de constantes annoncée par « Constante » ;
– déclaration de variables annoncée par « Variable » ;
– déclarations de sous programmes.
• Le corps est composé :
– du mot-clé « Début » ;
– d'une suite d'instructions indentées ;
– du mot-clé « Fin ».
• Commentaires entre (* et *) : aide-mémoire aux personnes visualisant
le programme 7

8. Algorithme
structure (2/2)
Programme nomDuProgramme
Type
(* Définition de types *)
Constante
(* Déclaration de constantes *)
Variable
(* Déclaration de variables *)
Déclaration de sous-programmes
Début
(* instructions du programme *)
Fin
Entête du programme
Corps du programme
8

9. Résolution d’un problème
cinq étapes
• Étape 1 : compréhension de l’énoncé du problème.
• Étape 2 : décomposition du problème en sous-problèmes. (Étape
nécessaire que si le problème initial n’est pas simple)
• Étape 3 : conception du problème ou de chaque sous-problème
• Étape 4 : algorithme logique du problème ou de chaque sous-
problème
• Étape 5 : algorithme de programmation du problème.
9

10. Résolution d’un problème
compréhension de l'énoncé
• Formulation ou reformulation du texte qui décrit le problème à
résoudre.
• Permet la compréhension du problème par soi-même : aucune
ambiguïté, complétude, cohérence ?
• Exemple ;-)
Après 3 heures d’attente, une dame appelle sa bonne qui est allé au
marché.
La dame : « Mais Fatou…, c’est quoi même ? »
La bonne : « Excuse-moi Madame, j’ai tout acheté sauf le total. Je
suis comme ça même, à la station d’essence Total. » 10

11. Résolution d’un problème
décomposition
• Cette étape est basée sur la
stratégie « diviser pour régner ».
• Commencer par décomposer le
problème initial en sous-problèmes,
puis chaque sous-problème en de
nouveaux sous-problèmes et ainsi
de suite jusqu’aux problèmes que
l’on peut résoudre à partir
d’opérations primitives.
• Question à se poser : quelles sont
les grandes étapes à réaliser ?
• NB : si le problème est simple,
l’étape de la décomposition n’est
pas nécessaire
Exemple sur l’algo du thé
1) Préparer la solution (eau + thé)
2) Bouillir la solution
3) Sucrer la solution
4) Produire de la mousse de thé
5) Servir le thé
11

12. Résolution d’un problème
conception - principe
Pour chaque problème simple :
1) identifier les données d’entrée : venant de l’extérieur et étant
nécessaires au problème ;
Exemple du sous-problème « Produire de la mousse de thé » :
théière remplie et verres à thé posés sur un plateau
2) identifier les données de sortie ou le résultat attendu du problème
par l’extérieur ;
Exemple du sous-problème « Produire de la mousse de thé » :
verres de mousse
3) Traitement (diapo suivante)
12
Traitemententrée sortie

13. Résolution d’un problème
conception – principe (suite)
3) traitement à faire :
• partir d’exemples de données d’entrée pour trouver le résultat
attendu et simuler graphiquement leurs traitements en
repérant les outils algorithmiques utilisés (saisie, opération,
affectation, affichage, test, répétition, … )
• s’il y a des outils imbriqués, commencer le traitement en
partant de l’intérieur
• ordonner, en numérotant, les étapes du traitement
• trouver toute formule, équation, fonction, constante et/ou autre
outil nécessaire au traitement
• pas besoin de respecter une syntaxe algorithmique
Exemple du sous-problème « Produire de la mousse de thé » :
matériel et actions nécessaires à l’obtention des verres de
mousse 13

14. Résolution d’un problème
conception - exemple
Enoncé du problème :
Algorithme qui affiche la somme de deux entiers donnés par l’utilisateur
14
1) lire() pour mémoriser terme1 et terme2
2) formule : terme1 + terme2 = somme
3) ecrire() pour afficher somme
• Données en entrée : deux entiers (terme1 et terme2)
• Résultat attendu : afficher la somme (somme) des deux entiers
• Traitement

15. Résolution d’un problème
algorithme logique - principe
• Traduction fidèle du traitement en pseudo-langage avec le respect de
la syntaxe algorithmique
• Constitué uniquement des instructions (en pseudo-langage)
indispensables au traitement : pas d’entête ni instruction superflue
15

16. Résolution d’un problème
algorithme logique - exemple
• Rappel du traitement de l’exemple précédent
1) lire() pour mémoriser terme1 et terme2
2) formule : terme1 + terme2 = somme
3) ecrire() pour afficher somme
• Algorithme logique de l’exemple précédent
lire(terme1, terme2)
somme ← terme1 + terme2
ecrire(somme)
16

17. Résolution d’un problème
algorithme de programmation - principe
• Algorithme qui complète l’algorithme logique avec
o une entête
 nom de l’algo,
 déclaration d’éventuelles constantes
 déclaration d’éventuelles variables
 …
o des instructions de présentation
 pour demander à l’utilisateur des données ?
 pour afficher des résultats ?
• Algorithme qu’on pourra traduire en langage de programmation
17

18. Résolution d’un problème
algorithme de programmation - exemple
• Rappel de l’algorithme logique de l’exemple précédent
lire(terme1, terme2)
somme ← terme1 + terme2
ecrire(somme)
• Algorithme de programmation de l’exemple précédent
Programme calculerSomme
Variable
terme1, terme2, somme : Entier
Début
ecrire("Entrez deux valeurs entières SVP ")
lire(terme1, terme2)
somme ← terme1 + terme2
ecrire(terme1," + ",terme2, " = ",somme)
Fin
18

19. Notion d’identificateur
 Nom donné aux diverses composantes (constantes, types, variables
et sous-programmes) d'un programme.
 Formé de lettres alphabétiques et de chiffres ainsi que du
caractère _ (espace souligné ou underscore).
 Le 1er caractère ne doit pas être un chiffre.
 Un identificateur doit être suffisamment explicite.
 Les variables et les sous-programmes commencent toujours par une
minuscule.
 Les types commencent toujours par une majuscule.
 Les constantes ne sont composées que de majuscules.
 Lorsque l’identifiant contient plusieurs mots, on articule ces mots avec
des majuscules ou avec le caractère _.
 Exemples : note1, fin_de_fichier, finDeFichier, TVA, PI
 Contre-exemples : 4eme, x#y, note-1, note 1.
19

20. Notion de variable
• Variable : emplacement dans la mémoire RAM pour le
stockage d’une donnée
• Exples sur l’algo du thé : paquet de thé, pot de sucre,
bouteille d’eau, verres à thé, théière
• Caractéristiques d’une variable :
o valeur ou contenu « provisoire » ;
o type décrivant un ensemble de valeurs et un ensemble d'opérateurs
sur ces valeurs ;
o identificateur ou nom permettant l’accès (R or W) à la variable.
• NB : toute variable utilisée dans le corps du programme doit d’abord être
déclarée dans l’entête.
• Déclaration d’une ou de plusieurs variables :
Variable identificateur1[,identificateur2, …] : Type
v
a
l
e
u
r
identificateur
20

21. Type de données
 Un type de données désigne la nature du contenu d’une variable
 Exples sur l’algo du thé : paquet de thé, pot de sucre, bouteille d’eau
 Un type de données définie l’ensemble des :
 valeurs que peut prendre une variable ;
 actions que l’on peut effectuer sur une variable.
 Une fois qu’un type de données est associé à une variable,
 le contenu de cette variable doit être du même type ;
 cette variable ne peut plus changer de type.
 Il y a deux grandes catégories de type :
 types simples ;
 types composites. 21

22. Types simples
numériques
• Naturel : entiers non signés (sous-ensemble de IN)
• Entier : positifs et négatifs (sous-ensemble de Z)
• Reel : sous-ensemble de IR
Exemples : 0.1, -1.2 (attention utilisation du . à la place de la ,)
• Exemples de déclaration de variables numériques
Variable
age : Naturel
temperature : Entier
taille, poids : Reel
22

23. Types simples
booléen, caractère et chaîne de caractères
• Booleen : les variables ne prennent que les valeurs VRAI ou FAUX
• Caractere : lettre, chiffre ou symbole (visible ou non) entouré par de
simples quotes (apostrophes)
Exples de littéraux de type Caractere : 'a', '3', 'n'
• ChaineDeCaracteres : suite de caractères entourée de doubles
quotes (guillemets).
Exple de littéral de type ChaineDeCaracteres : "Bonjour Ali",
• Exemples
Variable theRefroidi : Booleen
initiale : Caractere
nom : ChaineDeCaracteres
23

24. Constante
• Constante : donnée qui ne change jamais durant tout le programme
• Une constante a un identificateur, une valeur et un type induit par la
valeur
• Syntaxe de la déclaration d’une constante :
Constante IDENTIFICATEUR = valeur
• Lorsque l’identifiant d’une constante contient plusieurs mots, on les
articule avec le caractère _.
• Exemple
Constante
TVA = 0.18
24

25. Affectation
• Exples sur l’algo du thé : mettre de l’eau dans la théière ; remplir les
verres de thé ; transvaser du thé d’un verre à un autre
• L’usage d’un identificateur de variable diffère suivant sa position :
– à gauche du symbole d’affectation, l’identifiant nous permet de
définir ou de modifier la valeur de la variable
– à droite du symbole d’affectation, l’identifiant nous permet de
récupérer la valeur de la variable
App 1
25
• Avec le symbole ←, l’affectation a pour principal but
d’attribuer une valeur à une variable
• Syntaxe : identificateurVariable ←
expression
• Expression = combinaison de littéraux, de variables,
d'opérateurs, et/ou de fonctions qui est évaluée pour
produire une nouvelle valeur.

26. Opérateurs
présentation
• Opérateur : outil permettant de traiter des données
• Exemples sur l’algo du thé :
mélanger eau, thé et sucre; réchauffer le mélange
• Le type d’une donnée indique les opérations qu’elle peut subir
• Principaux opérateurs
– Arithmétiques (opérandes et résultat de type numérique)
– Relationnels (opérandes de tout type et résultat de type booléen)
– Logiques (opérandes et résultat de type booléen)
26

27. Opérateurs
arithmétiques
• Six opérateurs arithmétiques : addition (+), soustraction (-),
multiplication (x), division (/), division entière (DIV), reste de la
division entière ou modulo (MOD).
• Leurs opérandes peuvent être des entiers ou des réels hormis ceux
des deux derniers qui agissent uniquement sur des entiers.
• + et – sont aussi des opérateurs unaires (appliquer sur un seul
opérande)
Exemples : +2, -1.2
• Lorsque des opérandes de types différents sont utilisés, il y a
conversion implicite dans le type le plus fort.
Naturel < Entier < Reel
27

28. Opérateurs
relationnels
• Six opérateurs relationnels
< inférieur à
≤ inférieur ou égal à
> supérieur à
≥ supérieur ou égal à
= égal à
≠ différent de
• Le résultat d’une comparaison est un booléen
28

29. Opérateurs
logiques
• Trois opérateurs logiques : ET, OU, NON
• Tables de vérité
• L’évaluation est faite de gauche à droite et le processus est interrompu
dès que le résultat final est déterminé.
• NON est un opérateur unaire
A V V F F
B V F F V
A ET B V F F F
A OU B V V F V
NON A F F V V
Vraie si tous les opérandes sont vrais
Vraie si au moins l’un des opérandes est vrai
29

30. Opérateurs
priorité et associativité
• Lorsque plusieurs opérateurs sont utilisés dans la même instruction,
certains sont prioritaires par rapport à d'autres.
Exemple : -2 + 4 x 3 = 10
• Les parenthèses permettent de modifier l’ordre de priorité par défaut
Exemple : -(2 + 4) x 3 = -18
• Si les opérateurs ont la même priorité, l'associativité détermine leur
ordre d'exécution.
Exemple : -2 + 1 - 8 / 2 x 3 = -13
30

31. Opérateurs
Associativité et priorités par ordre décroissant
Catégorie Opérateurs Associativité
Référence ( ) [ ] . -> GD
Unaire +, -, NON DG
Arithmétique *, /, DIV, MOD GD
Arithmétique +, - GD
Relationnel <, ≤, >, ≥ GD
Relationnel =, ≠ GD
Logique ET GD
Logique OU GD
+
p
r
i
o
r
i
t
a
i
r
e
-
31

32. Entrées/sorties
• Un algorithme peut avoir des interactions avec l'utilisateur.
• L’outil ecrire() permet d’afficher des chaînes de caractères et des
valeurs d’expressions
• Une chaîne et une expression sont concaténées par une virgule
• Syntaxe : ecrire("chaîne de caractères", expression)
• L’outil lire() invite un utilisateur à saisir une (ou +sieurs) donnée(s)
pour une mémorisation dans une (ou +sieurs) variable(s).
• Syntaxe : lire(nomVar1 [,nomVar2, …])
• Exemple
ecrire("Entrez votre âge, puis votre taille SVP ?")
lire(age, taille)
ecrire("Vous avez ",age," ans et vous mesurez ",taille," mètres")
App 2
32

33. Structures de contrôle
présentation
• Par défaut, les instructions d’un programme sont exécutées d’une
manière séquentielle.
Exemple : 1. Mettre de l’eau dans la théière
2. Mettre du thé dans la théière
3. Poser la théière sur le fourneau
• Parfois, il est nécessaire qu’un traitement (une ou +sieurs instructions)
– ne soit pas systématiquement exécuté ;
Exemple : réchauffer le thé
– ou soit exécuté plusieurs fois.
Exemple : transvaser du thé d’un verre à un autre
D’où l’intérêt des structures de contrôle.
• Deux grands types de structures de contrôle :
– structures conditionnelles ou tests ;
– structures répétitives (ou itératives) ou boucles.
33

34. Structures de contrôle
structure conditionnelle stricte
• Structure utilisée si on souhaite exécuter un traitement seulement si
une condition est vraie et ne rien prévoir si cette condition est fausse.
Exemple : réchauffer thé
• Sa syntaxe :
Si (condition) Alors
traitement
FinSi
• Que le traitement soit exécuté ou non, le programme continue
normalement son exécution après l’instruction FinSi.
Exemple
Si (thé est très refroidi) Alors
réchauffer thé
FinSi
34

35. Structures de contrôle
structure conditionnelle alternative
• Structure permettant d'exécuter deux traitements différents en fonction
de la valeur booléenne d’une condition.
• Sa syntaxe :
Si (condition) alors
traitement_1
Sinon
traitement_2
FinSi
• Après l’exécution du traitement 1 ou bien du traitement 2, le
programme continue normalement son exécution juste après
l’instruction Finsi.
Exemple
Si (Il y a un bon film) Alors
aller au cinéma
Sinon
aller à la plage
FinSi
35

36. Structures de contrôle
structure conditionnelle alternative multiple
• La structure conditionnelle alternative multiple permet d'exécuter
plusieurs traitements différents en fonction de valeurs booléennes de
plusieurs conditions.
• Sa syntaxe :
Si (condition_1) Alors
traitement_1
Sinon si (condition_2) Alors
traitement_2
…
Sinon
traitement_n
FinSi
• Tout « Sinon » indique que toute condition précédente est fausseApp 3
Exemple
Si (Il y a un bon film) Alors
aller au cinéma
Sinon si (Il fait beau) Alors
aller à la plage
Sinon
regarder la télé
FinSi
36

37. Structures de contrôle
structure conditionnelle de choix
• Syntaxe :
Selon (expression) Faire
valeur1 : traitement1
valeur2 : traitement2
…
[Sinon : traitement par défaut]
FinSelon
Exemple
Selon (jour) Faire
1 : ecrire("On est lundi")
2 : ecrire("On est mardi")
3 : ecrire("On est mercredi")
4 : ecrire("On est jeudi")
5 : ecrire("On est vendredi")
6 : ecrire("On est samedi")
7 : ecrire("On est dimanche")
Sinon : ecrire(" Chiffre non valide")
FinSelon
• La structure conditionnelle de choix permet de choisir le traitement à
effectuer en fonction de la valeur d'une expression.
• Dès que l’expression est égale à une valeur, le traitement associé est
exécuté puis le programme continue normalement son exécution juste
après l’instruction FinSelon sans envisager les cas suivants.
37

38. Structures de contrôle
structure itérative « Tant que … Faire »
• La boucle Tant que … Faire permet de répéter un traitement tant
qu'une expression conditionnelle est vraie.
• Sa syntaxe :
Tant que (condition) faire
traitement
finTantQue
• La condition est testée avant toute exécution du traitement
• Ce traitement peut d’ailleurs ne jamais s’exécuter
• Le traitement doit faire évoluer une (ou des) variable(s) menant la
condition à la valeur FAUX pour éviter une boucle infinie
• Lorsque la condition devient fausse le programme continue
normalement son exécution après l’instruction qui suit le FinTantQue.
Exemple
Tant que (pas d’ébullition) faire
laisser la théière sur le réchaud
finTantQue
38

39. Structures de contrôle
structure itérative « Faire … Tant que »
• La boucle Faire … Tant que effectue la même tâche que la boucle
Tant que … Faire sauf que la condition ne commence à être testée
qu’après la 1ère itération
• Le traitement s’exécute au moins une fois.
• Sa syntaxe
Faire
traitement
Tant que (condition)
• Lorsque la condition devient fausse, le programme continue
normalement son exécution après l’instruction Tant que (condition).
Exemple
Faire
laisser la théière sur le réchaud
TantQue (pas d’ébullition)
39

40. Structures de contrôle
structure itérative « Pour »
• La boucle Pour permet de répéter un traitement un nombre connu de fois.
• Syntaxe
Pour var_compteur ← val_initiale à val_finale [pas de p] faire
traitement
FinPour
• La variable compteur est de type entier ; elle est initialisée à la valeur initiale et
elle augmente de p à chaque répétition du traitement.
• p : entier positif ou négatif et dont la valeur par défaut est 1.
• Exemples : Afficher « Bonjour » 15 fois
Pour i ← 1 à 15 faire
ecrire ("Bonjour")
FinPour
• Lorsque la variable compteur vaut la valeur finale, le traitement est exécuté
une dernière fois puis le programme sort de la boucle.
40
Pour i ← 15 à 1 pas de -1 faire
ecrire ("Bonjour")
FinPour

41. Structures de contrôle
choix d’une structure itérative
App 4 & 5
41
Nombre
d’itérations
connu ?
Traitement
exécuté au
moins 1 fois ?
Tant que … faire
Faire … Tant que
Pour
oui
oui
non
non

42. Tableaux
• Tableau : variable composite permettant de désigner sous un seul identifiant un
regroupement de données de même type afin de les traiter plus facilement.
• Les données sont mémorisées dans des cases contigües et repérées par des
indices (entiers naturels)
• Déclaration d’un tableau à une dimension
nomTab : tableau [DIM] de TypeDesDonnées
DIM = dimension du tableau = nombre de cases du tableau
• Déclaration et initialisation d’un tableau à une dimension
nomTab[] = {val1, val2, val3, …} de TypeDesDonnées
• Notation de l’accès (écriture ou lecture) à une case : nomTab[indice]
• L’indice varie de 0 à DIM – 1.
• Exemple : voyelles : tableau [6] de caractères
La case voyelles[1] contient la valeur'e'
données 'a' 'e' 'i' 'o' 'u' 'y'
indices 0 1 2 3 4 5
App 6
42
0 1 2

43. Sous-programmes
présentation
• Les sous-programmes permettent :
– d’implémenter la décomposition d’un problème en sous-problèmes ;
– de faciliter la lisibilité, le débogage et la réutilisabilité/factorisation ;
• Comme le programme principal, tout sous-programme possède un nom,
un corps, des instructions et éventuellement des variables.
• Mais un sous-programme n’est exécuté que lorsqu’il est appelé par un
autre (sous-)programme.
• Deux types de sous-programme :
 procédure qui fait une certaine tâche ;
 fonction qui renvoie, en plus, une valeur résultat.
• L'appel d'une procédure constitue une instruction en lui-même.
• L'appel d'une fonction est remplacé à l'exécution par la valeur retournée
par celle-ci. Il doit forcément se trouver dans un calcul, une affectation,
un affichage, un test, etc. 43

44. Sous-programmes
portée des variables
• Portée d’une variable = étendue de son accessibilité
• Toute variable déclarée dans un sous-programme est dite locale et
n’est accessible que dans ce sous-programme.
• Toute variable déclarée en dehors de tout sous-programme est dite
globale et est accessible de partout.
• Les constantes ont généralement une portée globale
• Un même identificateur de variable peut être utilisé pour désigner des
variables locales de différents sous-programmes sans aucune
ambiguïté.
• En revanche, une variable globale n'existe qu'en un seul exemplaire
pour tous les sous-programmes.
• Lorsqu’une variable locale a le même identificateur qu'une variable
globale, cette dernière est localement masquée; dans ce sous-
programme la variable globale devient inaccessible. 44

45. Sous-programmes
paramètres
• Rappelons qu’un sous-programme n’est exécuté que
lorsqu’il est appelé par un autre (sous-)programme.
• La communication entre sous-programme appelé et (sous-)programme
appelant se fait par l'intermédiaire de variables locales au sous-
programme appelé que l’on nomme « paramètres formels ».
• Lors de l’appel, tout paramètre formel est associé à une variable ou une
constante de même type nommée « paramètre effectif » du
(sous-)programme appelant.
• Il existe trois types d'association ou de passage de paramètre :
– passage de paramètres en entrée ;
– passage de paramètres en sortie ;
– passage de paramètres en entrée/sortie. 45

46. Sous-programmes
passage de paramètres en entrée
• Les instructions du sous-programme appelé ne peuvent pas modifier le
paramètre effectif.
• En fait, c'est uniquement la valeur du paramètre effectif qui est copiée
dans le paramètre formel
• C'est le seul passage de paramètre qui admet l'utilisation d'une
constante comme paramètre effectif.
• Exemple :
Le sous-programme ecrire() qui permet d'afficher des informations
admet des paramètres en entrée.
46

47. Sous-programmes
passage de paramètres en sortie
• Les instructions du sous-programme appelé affectent obligatoirement
une valeur au paramètre formel (valeur qui est donc aussi affectée au
paramètre effectif associé)
• Eviter d’utiliser des constantes comme paramètre effectif pour ce type
de passage de paramètres.
• La valeur que pouvait posséder le paramètre effectif n'est pas utilisée
par le sous-programme appelé.
• Exemple :
Le sous-programme lire() qui permet de mettre dans des variables
des valeurs entrées par l'utilisateur admet des paramètres en sortie
47

48. Sous-programmes
passage de paramètres en entrée/sortie
• Passage de paramètre qui combine les deux précédents
• A utiliser lorsque le sous-programme appelé doit utiliser puis modifier la
valeur du paramètre effectif.
• Comme pour le passage de paramètre en sortie, on ne peut pas utiliser
une constante comme paramètre effectif
• Exemple :
Le sous-programme permuter() qui permet de permuter les valeurs
de deux variables admet des paramètres en entrée/sortie
48

49. Sous-programmes
fonctions - présentation
• Une fonction est un sous-programme admettant 1 ou +sieurs paramètre(s)
et retournant un seul résultat (en Maths y = f(a,b,…))
• Une fonction possède un type qui est celui de la valeur retournée
• Le passage de paramètres est uniquement en entrée
• Un paramètre effectif peut être une variable, une constante mais aussi le
résultat d’une fonction
• Syntaxe de la définition d’une fonction :
Fonction nomFonction(nomParam1 : TypeParam1[,…]) :
TypeRslt Variable
Déclaration des éventuelles variables locales
Début
instruction(s)
retourne rslt
FinFonction
• Syntaxe de la déclaration d’une fonction dans un programme appelant :
Fonction nomFonction(TypeParam1[,…]) : TypeRslt 49

50. Sous-programmes
fonctions - exemple
(* Définition de la fonction *)
Fonction additionner(p_terme1 : Reel, p_terme2 : Reel ) :
Reel
Variable somme : Reel
Début
somme ← p_terme1 + p_terme2
retourne somme
FinFonction
(* Appel de la fonction *)
Programme test_additionner
Variable terme1, terme2 : Reel
Fonction additionner(Reel, Reel) : Reel
Début
ecrire("Entrez deux valeurs entières SVP ")
lire(terme1, terme2)
ecrire(terme1," + ",terme2, " = ",
additionner(terme1,terme2))App 7
50

51. Sous-programmes
procédures - présentation
• Une procédure est un sous-programme qui ne retourne aucun résultat
• Par contre elle peut admettre des paramètres avec des passages :
– en entrée, préfixés par E (ou →)
– en sortie, préfixés par S (ou ←)
– en entrée/sortie, préfixés par E/S (ou ↔)
• Syntaxe de la définition d’une procédure :
Procédure nomProcedure([ modePassage
nomParam1:typeParam1[,…] ]) Variable
Déclaration d’éventuelles variables locales
Début
instruction(s)
FinProcédure
• Syntaxe de la déclaration d’une procédure dans un programme appelant
Procédure nomProcedure([ modePassage typeParam1[,…]
]) 51

52. Sous-programmes
procédures - exemple
(* Définition de la procédure *)
Procédure somEtDif(E a : Reel, E b : Reel, S som : Reel, S dif : Reel)
Début
som ← a + b
dif ← a - b
finProcédure
(* Appel de la procédure *)
Programme test_somEtDif
Variable terme1, terme2, somme, difference : Reel
Procédure somEtDif(E Reel, E Reel, S Reel, S Reel)
Début
ecrire("Entrez deux valeurs entières SVP ")
lire(terme1, terme2)
somEtDif(terme1, terme2, somme, difference)
ecrire(terme1," + ",terme2, " = ", somme)
ecrire(terme1," - ",terme2, " = ", difference)
Fin App 8
52

53. Enregistrements
présentation
• Enregistrement = variable composite qui permet de désigner sous
un seul identifiant un regroupement de données connexes de types
différents ou non, afin de les manipuler plus facilement
• L’usage d’un enregistrement est précédé de la définition d’un
nouveau type, structuré par des champs de types différents ou non
• Syntaxe de la définition d’un type structuré :
TYPE NomType=structure
nomChamp1 : typeChamp1
…
nomChampN : typeChampN
finStructure
• Exemple : médicament modélisé par nom, prix et quantité en stock
TYPE Medicament=structure
nom : ChaineDeCaracteres
prix : Naturel
quantiteEnStock : Naturel
finStructure 53

54. Enregistrements
déclaration et accès
• Syntaxe de la déclaration d’un enregistrement :
Variable nomEnregistrement : NomType
• Syntaxe de l’accès à un champ d’un enregistrement :
nomEnregistrement.nomChamp
• Un champ s’utilise comme une variable simple
• Exemple
Variable myMedic : Medicament
(* Accès en écriture *)
myMedic.nom ← "Doliprane"
myMedic.prix ← 1024
(* Accès en lecture puis en écriture *)
myMedic.quantiteEnStock ← myMedic.quantiteEnStock -
1
App 9
54