09/05/2014

Les catégories d’ordres

Notion de variable
Algorithmique  les ordinateurs, quels qu’ils soient, ne sont  Dans les langages de programmation une variable sert à stocker
fondamentalement capables de comprendre que la valeur d’une donnée
quatre catégories d'ordres (en programmation, on
 Une variable désigne en fait un emplacement mémoire dont
n'emploiera pas le terme d'ordre, mais plutôt celui
d'instructions). Ces quatre familles d'instructions le contenu peut changer au cours d’un programme (d’où le nom
variable)
sont :
Notions et instructions de base • Les variables et leurs affectation  Règle : Les variables doivent être déclarées avant d’être
• la lecture / écriture utilisées, elle doivent être caractérisées par :
• les tests • un nom (Identificateur)
• les boucles • un type (entier, réel, caractère, chaîne de caractères, …)

1 2 3

Choix des identificateurs (1)
Le choix des noms de variables est soumis à quelques règles qui
varient selon le langage, mais en général:
 Un nom doit commencer par une lettre alphabétique
exemple valide: A1 exemple invalide: 1A
 doit être constitué uniquement de lettres, de chiffres et du
soulignement _ (Eviter les caractères de ponctuation et les espaces)
valides: SMI2007, SMI_2007 invalides: SMI 2007, SMI-2007, SMI;2007
 doit être différent des mots réservés du langage (par exemple en
Java: int, float, else, switch, case, default, for, main, return, …)
Choix des identificateurs (2)
Conseil: pour la lisibilité du code choisir des noms significatifs
qui décrivent les données manipulées
exemples: TotalVentes2006, Prix_TTC, Prix_HT
Remarque: en pseudo-code algorithmique, on va respecter
les règles citées, même si on est libre dans la
syntaxe
Types des variables
Le type d’une variable détermine l’ensemble des valeurs qu’elle peut
prendre, les types offerts par la plus part des langages sont:
 Type numérique (entier ou réel)
• Byte (codé sur 1octet): de 0 à 255
• Entier court (codé sur 2 octets) : -32 768 à 32 767
• Entier long (codé sur 4 ou 8 octets)
• Réel simple précision (codé sur 4 octets)
• Réel double précision (codé sur 8 octets)
 Type logique ou booléen: deux valeurs VRAI ou FAUX
 Type caractère: lettres majuscules, minuscules, chiffres, symboles, …
exemples: ’A’, ’a’, ’1’, ’?’, …

 La longueur du nom doit être inférieure à la taille maximale spécifiée  Type chaîne de caractère: toute suite de caractères,
par le langage utilisé exemples: " Nom, Prénom", "code postale: 1000", …

4 5 6

Exercices simples sur

Déclaration des variables L’instruction d’affectation l'affectation (1)
 l’affectation consiste à attribuer une valeur à une variable
 Rappel: toute variable utilisée dans un programme doit avoir Donnez les valeurs des variables A, B et C après exécution
(ça consiste en fait à remplir où à modifier le contenu d'une zone mémoire)
fait l’objet d’une déclaration préalable des instructions suivantes ?
 En pseudo-code, on va adopter la forme suivante pour la  En pseudo-code, l'affectation se note avec le signe ←
déclaration de variables Var← e : attribue la valeur de e à la variable Var Variables A, B, C: Entier
Variables liste d'identificateurs : type - e peut être une valeur, une autre variable ou une expression Début
 Exemple: - Var et e doivent être de même type ou de types compatibles
A←3
B←7
Variables i, j,k : entier - l’affectation ne modifie que ce qui est à gauche de la flèche
A←B
x, y : réel  Ex valides: i ←1 j ←i k ←i+j B ← A+5
OK: booléen x ←10.3 OK ←FAUX ch1 ←"SMI" C←A+B
ch1, ch2 : chaîne de caractères ch2 ←ch1 x ←4 x ←j C←B–A
(voir la déclaration des variables dans le transparent précédent)
Fin
 Remarque: pour le type numérique on va se limiter aux entiers
et réels sans considérer les sous types  non valides: i ←10.3 OK ←"SMI" j ←x
7 8 9

1
 09/05/2014

Exercices simples sur l'affectation (2) Exercices simples sur l'affectation (3) Expressions et opérateurs
Donnez les valeurs des variables A et B après exécution des  Une expression peut être une valeur, une variable ou une
Ecrire un algorithme permettant d’échanger les opération constituée de variables reliées par des opérateurs
instructions suivantes ?
valeurs de deux variables A et B exemples: 1, b, a*2, a+ 3*b-c, …
Variables A, B : Entier  L'évaluation de l'expression fournit une valeur unique qui est le
Début résultat de l'opération
A←1
B←2  Les opérateurs dépendent du type de l'opération, ils peuvent être :
A←B
B←A
• des opérateurs arithmétiques: +, -, *, /, % (modulo), ^ (puissance)

Fin
• des opérateurs logiques: NON, OU, ET
• des opérateurs relationnels: =,  , <, >, <=, >=

Les deux dernières instructions permettent-elles d’échanger les • des opérateurs sur les chaînes: & (concaténation)
valeurs de A et B ?  Une expression est évaluée de gauche à droite mais en tenant
compte de priorités
10 11 12

Les instructions d'entrées- Les instructions d'entrées-

Priorité des opérateurs sorties: lecture et écriture (1) sorties: lecture et écriture (2)

 Pour les opérateurs arithmétiques donnés ci-dessus, l'ordre de  Les instructions de lecture et d'écriture permettent à la machine de  L'écriture permet d'afficher des résultats à l'écran (ou de les écrire
priorité est le suivant (du plus prioritaire au moins prioritaire) : communiquer avec l'utilisateur dans un fichier)
 La lecture permet d'entrer des donnés à partir du clavier
•
•
^ : (élévation à la puissance)
• En pseudo-code, on note: écrire (var)
* , / (multiplication, division) • En pseudo-code, on note: lire (var)
• % (modulo)
la machine met la valeur entrée au clavier
la machine affiche le contenu de la
• + , - (addition, soustraction) dans la zone mémoire nommée var
zone mémoire var
exemple: 2+3*7 vaut 23
• Remarque: Le programme s'arrête lorsqu'il rencontre une
• Conseil: Avant de lire une variable, il est fortement conseillé
d’écrire des messages à l’écran, afin de prévenir l’utilisateur de
 En cas de besoin (ou de doute), on utilise les parenthèses pour instruction Lire et ne se poursuit qu'après la frappe d’une valeur
ce qu’il doit frapper
indiquer les opérations à effectuer en priorité au clavier et de la touche Entrée
exemple: (2 + 3) * 7 vaut 35

13 14 15

Méthode de construction d’un

Exemple (lecture et écriture) Exercice (lecture et écriture) algorithme simple (1/4)
Ecrire un algorithme qui demande un nombre entier à l'utilisateur, puis Ecrire un algorithme qui vous demande de saisir votre nom puis
qui calcule et affiche le double de ce nombre votre prénom et qui affiche ensuite votre nom complet Exemple :
Algorithme Calcul_double Algorithme AffichageNomComplet
variables A, B : entier variables Nom, Prenom, Nom_Complet : chaîne de caractères
Écrire un algorithme qui consiste a calculer l’air S
Début
Début écrire("entrez votre nom") d’un cercle selon la formule S = Pi * R2
écrire("entrer la valeur de A ") lire(Nom) Rappel : Pi = 3.14159 et R le rayon du cercle
lire(A) écrire("entrez votre prénom")
lire(Prenom)
B ← 2*A Nom_Complet ← Nom & Prenom
écrire("le double de ", A, "est :", B) écrire("Votre nom complet est : ", Nom_Complet)
Fin Fin

16 17 18

2
 09/05/2014

Méthode de construction d’un algorithme Méthode de construction d’un

simple (2/4) algorithme simple (3/4)

Méthodologie a suivre : Algorithme Algorithmique

 constantes : Pi = 3.14159 Calcul_Aire
Constantes
 Variables : Rayon, Surface Pi = 3,14159
Variables
 Types : Rayon, Surface : réel
Rayon, Surface : réels Les structures
 Expressions et affectation : Surface := Pi * (Rayon)2 Début
lire (Rayon)
Conditionnelles et les
 Structures conditionnelles et les boucles : ------ Surface := Pi * (Rayon)2 boucles
 Opérations d’entrée-sortie : Lire (Rayon),
écrire (Surface)
Fin
Écrire (Surface)

19 20 21

Besoin a des concepts de ruptures de Les structures conditionnelles

séquence et les boucles Tests: instructions conditionnelles (1)
 Les instructions conditionnelles servent à n'exécuter une instruction
Algorithme  Les tests simples : permet de réaliser un choix parmi deux ou une séquence d'instructions que si une condition est vérifiée
 Rare les algorithme qui peuvent se possibilités (Ex :Booléenne : vrais ou faux)
Calcul_Aire décrire uniquement par un
enchaînement séquentiel  Les instructions conditionnelles : c’est un concept  On utilisera la forme suivante: Si condition alors
Constantes de tests multiples, permet de comparer un objet à une série de instruction ou suite d'instructions1
d’opération élémentaire
Pi = 3,14159 valeurs, et exécuter si la condition est vérifier (Ex : recherche des
nombres premier dans une ensemble) Sinon
Variables
 On a besoin a des concept de rupture instruction ou suite d'instructions2
Rayon, Surface : réels de séquence comme les test et les
Début boucles  Les itérations : consiste a exécuté un bloc d’instructions un Finsi
lire (Rayon) Ex : certain nombre de fois (Ex : calcul d’une suite numérique) • la condition ne peut être que vraie ou fausse
 un algorithme qui résout une
Surface := Pi * (Rayon)2
équation de deuxième degré • si la condition est vraie, se sont les instructions1 qui seront exécutées
écrire (Surface)  un algorithme qui calcule une série  Les boucles conditionnelles : consiste a exécuté un
• si la condition est fausse, se sont les instructions2 qui seront exécutées
Fin numérique bloc d’instructions un certain nombre de fois si la condition est
vérifier (Ex : On veut afficher le 100 premiers nombres :. Tant que i est plus • la condition peut être une condition simple ou une condition composée de
petit que 100, afficher la valeur de i). plusieurs conditions
22 23 24

Tests: instructions conditionnelles (2) Exemple (Si…Alors…Sinon) Exemple (Si…Alors)

 La partie Sinon n'est pas obligatoire, quand elle n'existe pas et que
Algorithme AffichageValeurAbsolue (version1) Algorithme AffichageValeurAbsolue (version2)
la condition est fausse, aucun traitement n'est réalisé
Variable x : réel Variable x,y : réel
• On utilisera dans ce cas la forme simplifiée suivante: Début Début
Ecrire " Entrez un réel : " Ecrire " Entrez un réel : "
Si condition alors Lire (x) Lire (x)
instruction ou suite d'instructions1 Si x < 0 alors y← x
Finsi Ecrire ("la valeur absolue de ", x, "est:",-x) Si x < 0 alors
Sinon y ← -x
Ecrire ("la valeur absolue de ", x, "est:",x) Finsi
Finsi Ecrire ("la valeur absolue de ", x, "est:",y)
Fin Fin

25 26 27

3
 09/05/2014

Exercice (tests) Conditions composées Tables de vérité

Ecrire un algorithme qui demande un nombre entier à l'utilisateur,  Une condition composée est une condition formée de plusieurs C1 C2 C1 ET C2 C1 C2 C1 OU C2
puis qui teste et affiche s'il est divisible par 3 conditions simples reliées par des opérateurs logiques:
VRAI VRAI VRAI VRAI VRAI VRAI
Algorithme Divsible_par3 ET, OU, OU et NON
VRAI FAUX FAUX VRAI FAUX VRAI
Variable n : entier  Exemples : FAUX VRAI FAUX FAUX VRAI VRAI
Début • x compris entre 2 et 6 : (x > 2) ET (x < 6) FAUX FAUX FAUX FAUX FAUX FAUX
Ecrire " Entrez un entier : "
Lire (n) • n divisible par 3 ou par 2 : (n%3=0) OU (n%2=0)
C1 C2 C1 XOR C2 C1 NON C1
Si (n%3=0) alors • deux valeurs et deux seulement sont identiques parmi a, b et c :
VRAI VRAI FAUX VRAI FAUX
Ecrire (n," est divisible par 3")
(a=b) XOR (a=c) XOR (b=c)
Sinon VRAI FAUX VRAI FAUX VRAI
Ecrire (n," n'est pas divisible par 3") FAUX VRAI VRAI
 L'évaluation d'une condition composée se fait selon des règles
Finsi présentées généralement dans ce qu'on appelle tables de vérité FAUX FAUX FAUX
Fin
28 29 30

Tests imbriqués Tests imbriqués: exemple (version 1) Tests imbriqués: exemple (version 2)
 Les tests peuvent avoir un degré quelconque d'imbrications Variable n : entier Variable n : entier
Début Début
Si condition1 alors
Ecrire ("entrez un nombre : ") Ecrire ("entrez un nombre : ")
Si condition2 alors Lire (n)
Lire (n)
instructionsA Si n < 0 alors Si n < 0 alors Ecrire ("Ce nombre est négatif")
Sinon Ecrire ("Ce nombre est négatif") Finsi
instructionsB Si n = 0 alors Ecrire ("Ce nombre est nul")
Sinon
Finsi
Finsi Si n = 0 alors Si n > 0 alors Ecrire ("Ce nombre est positif")
Sinon Ecrire ("Ce nombre est nul")
Finsi
Si condition3 alors Sinon Fin
instructionsC Ecrire ("Ce nombre est positif") Remarque : dans la version 2 on fait trois tests systématiquement alors que
Finsi Finsi dans la version 1, si le nombre est négatif on ne fait qu'un seul test
Finsi Conseil : utiliser les tests imbriqués pour limiter le nombre de tests et placer
Finsi
d'abord les conditions les plus probables (minimiser la complexité)
Fin
31 32 33

Tests imbriqués: exercice Tests imbriqués: corrigé de l'exercice Tests imbriqués: Exercice 2
Variables copies : entier
Le prix de photocopies dans une reprographie varie selon le prix : réel
nombre demandé: 0,5 DH la copie pour un nombre de copies Début Écrire l’algorithme du traitement qui calcule le discriminant
inférieur à 10, 0,4DH pour un nombre compris entre 10 et 20 et Ecrire ("Nombre de photocopies : ") DELTA d’trinome du second degré AX2 + BX + C et qui, en
0,3DH au-delà. Lire (copies) fonction de son signe, calcule la ou les racines réelles du
Si copies < 10 Alors trinome ou afiche, si besoin est qu’il n’ya pas de racine réelle.
Ecrivez un algorithme qui demande à l’utilisateur le nombre de prix ← copies*0.5
photocopies effectuées, qui calcule et affiche le prix à payer Sinon Si copies < 20 Les trois coefficients A, B et C seront saisis au clavier avant
prix ← copies*0.4
traitement.
Sinon
prix ← copies*0.3
Finsi
Finsi
Ecrire (“Le prix à payer est : ”, prix)
Fin

34 35 36

4
 09/05/2014

Les types de boucle

Tests imbriqués: corrigé de l'exercice 2
Variables

Début
A, B, C, Delta, X1, X2 : réels Algorithmique  On distingue 2 types de boucles:
Lire (A, B, C)
Delta ← B2 – 4 AC • Les boucles à compteur ou définie
Si (Delta < 0) Alors • On sait à l’avance combien de fois la boucle devra tourner et
Ecrire (« le trinome n’a pas de racine réelle ») une variable (le compteur ) compte les répétitions
Sinon • Choisir 10 nombres au hasard. On fera dix fois l’opération choisir
Si (Delta > 0 Alors un nombre au hasard.
X1 ← (-B + racine(delta)) / 2A • Ex : la boucle Pour
X2 ← (-B - racine(delta)) / 2A

Ecrire (« le trinome possède deux racines réelles : », X1, X2) Les boucles • Les boucles à événement ou indéfinie
Sinon • On ne sait pas à l’avance le nombre de fois que la boucle sera
exécutée.
X1 ← (-B ) / 2A • Ça peut dépendre du nombre de données à traiter.
Ecrire (« le trinome possède une racine réelle : », X1) • Ça peut dépendre du nombre d’essais que l’usager a effectués.
Finsi • Ex : la boucle Tanque et la boucle jusqu’a
Finsi

Fin
37 38 39

Les boucles Tant que Boucle Tant que : exemple simple Les boucles Pour
Un algorithme qui détermine le premier nombre entier N tel que la
Pour compteur allant de initiale à finale par pas valeur du pas
somme de 1 à N dépasse strictement 100
TantQue (condition)
instructions
Variables som, i : entier
instructions Debut FinPour
i←0
i ←initiale
som← 0
FinTantQue Vrai TantQue (som <=100)
condition instructions
i ← i+1
som ← som+i Vrai
Faux i n'a pas atteint finale instructions i ← i + pas
FinTantQue
Ecrire (" La valeur cherchée est N= ", i)
Fin Faux

40 41 42

Les boucles Pour
Remarques :
 Compteur est une variable de type entier (ou caractère). Elle doit
être déclarée
 Pas est un entier qui peut être positif ou négatif. Pas peut ne pas
être mentionné, car par défaut sa valeur est égal à 1. Dans ce cas, le
nombre d'itérations est égal à finale - initiale+ 1
 Initiale et finale peuvent être des valeurs, des variables définies
avant le début de la boucle ou des expressions de même type que
compteur
Déroulement des boucles Pour Boucle Pour : remarque
1) La valeur initiale est affectée à la variable compteur  Il faut éviter de modifier la valeur du compteur (et de finale) à
l'intérieur de la boucle. En effet, une telle action :
2) On compare la valeur du compteur et la valeur de finale :
• perturbe le nombre d'itérations prévu par la boucle Pour
a) Si la valeur du compteur est > à la valeur finale dans le cas d'un pas
positif (ou si compteur est < à finale pour un pas négatif), on sort de la
• rend difficile la lecture de l'algorithme
boucle et on continue avec l'instruction qui suit FinPour • présente le risque d'aboutir à une boucle infinie
b) Si compteur est <= à finale dans le cas d'un pas positif (ou si compteur Exepmle : Pour i allant de 1 à 5
est >= à finale pour un pas négatif), instructions seront exécutées i  i -1
écrire(" i = ", i)
i. Ensuite, la valeur de compteur est incrémentée de la valeur du pas
Finpour
si pas est positif (ou décrémenté si pas est négatif)
ii. On recommence l'étape 2 : La comparaison entre compteur et
finale est de nouveau effectuée, et ainsi de suite …

43 44 45

5
 09/05/2014

Lien entre Pour et TantQue: exemple

Lien entre Pour et TantQue Solution avec la boucle Pour
La boucle Pour est un cas particulier de Tant Que (cas où le nombre
d'itérations est connu et fixé) . Tout ce qu'on peut écrire avec Pour peut être Variables x, puiss : réel
remplacé avec TantQue (la réciproque est fausse) Calcul de x à la puissance n n, i : entier
Pour compteur allant de initiale à finale par pas valeur du pas avec la boucle Pour et la Debut
boucle TantQue Ecrire (" Entrez respectivement les valeurs de x et n ")
instructions Lire (x, n)
FinPour x : un réel non nul puiss ← 1
peut être remplacé par : compteur ← initiale n : entier positif ou nul Pour i allant de 1 à n
(cas d'un pas positif) TantQue compteur <= finale puiss← puiss*x
FinPour
instructions
Ecrire (x, " à la puissance ", n, " est égal à ", puiss)
compteur ← compteur+pas
Fin
FinTantQue

46 47 48

Solution avec la boucle Tant Que Algorithme de la fonction factorielle : Exemple

Algorithme de la fonction factorielle

Variables x, puiss : réel  Écrire deux algorithmes qui calculent Algorithme / tantque Algorithme / Pour
Calcul factorielle 1
n, i : entier pour un entier positif donné n la valeur Variables
Calcul factorielle 2
Variables
Debut
Ecrire (" Entrez respectivement les valeurs de x et n ") n!, un de ces algorithmes doit utilisé la i, f, n : Naturel i, f, n : Naturel
Début
Lire (x, n) boucle Pour et l’autre la boucle Tanque i←1
Début
f←1
puiss ← 1, i ← 1
f←1 pour i variant de 2 à n
TantQue (i<=n) tant que (i < n) f←f*i
puiss← puiss*x i ← i+1 Fin pour
i ← i+1 Entrée : n de type naturel f←f*i écrire (f)
FinTantQue
Ecrire (x, " à la puissance ", n, " est égal à ", puiss)
Sortie : factoriel (n) = 1*2*3*…..*(n-1)*n Fin de tant que
écrire (f)
Fin

Fin Fin

49 50 51

La boucle Faire…Tant Que

Boucles imbriquées Les boucles Répéter … jusqu’à …
 Les instructions d'une boucle peuvent être des instructions • Faire Répéter
itératives. Dans ce cas, on aboutit à des boucles imbriquées Instruction(s)
Tant que (condition) Instruction(s) de la instructions instructions
 Exemple: Exécution • do
boucle

Jusqu'à condition
Pour i allant de 1 à 5 OX Instruction;
Faux
Pour j allant de 1 à i OOX while (condition) condition
condition
écrire("O") OOOX Vraie
do Vrai
FinPour OOOOX
{ La boucle s’exécute tant que la Fausse
écrire("X") OOOOOX  Condition est évaluée après chaque itération
f :=n; condition est vraie. La boucle
FinPour n--; cesse lorque la condition est
 les instructions entre Répéter et jusqu’à sont exécutées au moins une fois et
fausse. À utiliser si l’on veut que la
} while (n>1); leur exécution est répétée jusqu’à ce que condition soit vrai (tant qu'elle est
boucle soit exécutée au moins une
fausse)
fois
52 53 54

6
 09/05/2014

Boucle Répéter jusqu’à : exemple Choix d'un type de boucle

Un algorithme qui détermine le premier nombre entier N tel que la somme de 1
à N dépasse strictement 100 (version avec répéter jusqu'à)
 Si on peut déterminer le nombre d'itérations avant l'exécution de la
boucle, il est plus naturel d'utiliser la boucle Pour
Algorithmique
Variables som, i : entier  S'il n'est pas possible de connaître le nombre d'itérations avant
Debut l'exécution de la boucle, on fera appel à l'une des boucles TantQue
som ← 0 ou répéter jusqu'à
i←0
Répéter  Pour le choix entre TantQue et jusqu'à :
i ← i+1
• Si on doit tester la condition de contrôle avant de commencer les
Fonctions et procédures
som ← som+i instructions de la boucle, on utilisera TantQue
Jusqu'à ( som > 100)
Ecrire (" La valeur cherchée est N= ", i) • Si la valeur de la condition de contrôle dépend d'une première
exécution des instructions de la boucle, on utilisera répéter jusqu'à ou
Fin faire tanque
55 56 57

Notion de bloc dans un

Fonctions et procédures programme Fonctions
 Lorsqu’une séquence d’instructions se répète plusieurs fois, il est
intéressant de faire un sous-programme correspondant à ce bloc
d’instructions et de l’utiliser autant de fois que nécessaire

 Cette séquence d’instructions sera définie dans un sous-programme

qui peut prendre la forme d’une procédure ou d’une fonction

 De plus, un programme est presque toujours décomposable en

modules qui peuvent alors être définis de manière indépendante.
Cela permet de modifier éventuellement un module sans pour autant
changer le corps du programme et de rendre le programme plus
compréhensible (lisibilité)

 Un programme est alors un ensemble de procédures / fonctions

58 59 60

Forme d’une Fonction Exemple de programme / fonction Exemple de fonction / fonction

 Une fonction s'écrit en dehors du programme principal sous la forme

Fonction identificateur (paramètres et leurs types) : type_fonction

Instructions constituant le corps de la fonction

retourne …
FinFonction

 type de fonction : le type du résultat renvoyé par la fonction

 Identificateur : le nom que l’on a donné à la fonction
 liste de paramètres : la liste des paramètres formels donnés en entrée
avec leurs types
 corps de la fonction : un bloc d’instructions, pouvant comprendre la
déclaration des « variables locales » a la fonctions
Remarque : le corps de la fonction doit comporter une instruction de la forme :
return(expression); où expression est du type du résultat de la fonction

61 62 63

7
 09/05/2014

Fonctions : exemples Utilisation des fonctions Procèdures

 La fonction SommeCarre suivante calcule la somme des carrées de  L'utilisation d'une fonction se fera par simple écriture de son nom  Dans certains cas, on peut avoir besoin de répéter une tache dans plusieurs
dans le programme principale. Le résultat étant une valeur, devra endroits du programme, mais que dans cette tache on ne calcule pas de
deux réels x et y :
être affecté ou être utilisé dans une expression, une écriture, ... résultats ou qu'on calcule plusieurs résultats à la fois
Fonction SommeCarre (x : réel, y: réel ) : réel
variable z : réel  Exepmle : Algorithme exepmleAppelFonction  Dans ces cas on ne peut pas utiliser une fonction, on utilise une procédure
z ←x^2+y^2 Paramètres variables z : réel, b : booléen  Une procédure est un sous-programme semblable à une fonction mais qui
retourne (z) formels Début ne retourne rien
FinFonction b ←Pair(3)  Une procédure s'écrit en dehors du programme principal sous la forme :
z ←5*SommeCarre(7,2)+1
Procédure nom_procédure (paramètres et leurs types)
 La fonction Pair suivante détermine si un nombre est pair : écrire("SommeCarre(3,5)= ", SommeCarre(3,5))
Fin Instructions constituant le corps de la procédure
Fonction Pair (n : entier ) : booléen
retourne (n%2=0)  Lors de l'appel Pair(3) le paramètre formel n est remplacé par le FinProcédure
FinFonction paramètre effectif 3  Remarque : une procédure peut ne pas avoir de paramètres
64 65 66

Appel d'une procédure Paramètres d'une procédure Transmission des paramètres

 L'appel d'une procédure, se fait dans le programme principale ou dans une  Les paramètres servent à échanger des données entre le programme Il existe deux modes de transmission de paramètres dans les langages de
autre procédure par une instruction indiquant le nom de la procédure : principale (ou la procédure appelante) et la procédure appelée programmation :
Procédure exemple_proc (…)  La transmission par valeur : les valeurs des paramètres effectifs sont
…  Comme avec les fonctions : affectées aux paramètres formels correspondants au moment de l'appel de la
FinProcédure • Les paramètres placés dans la déclaration d'une procédure sont appelés procédure. Dans ce mode le paramètre effectif ne subit aucune modification
paramètres formels. Ces paramètres peuvent prendre toutes les valeurs
possibles mais ils sont abstraits (n'existent pas réellement)  La transmission par adresse (ou par référence) : les adresses des
Algorithme exepmleAppelProcédure
paramètres effectifs sont transmises à la procédure appelante. Dans ce
Début
• Les paramètres placés dans l'appel d'une procédure sont appelés paramètres mode, le paramètre effectif subit les mêmes modifications que le paramètre
exemple_proc (…) effectifs. ils contiennent les valeurs pour effectuer le traitement formel lors de l'exécution de la procédure
…
Fin
 Le nombre de paramètres effectifs doit être égal au nombre de paramètres
• Remarque : le paramètre effectif doit être une variable (et non une
valeur) lorsqu'il s'agit d'une transmission par adresse
 Remarque : contrairement à l'appel d'une fonction, on ne peut pas affecter la formels. L'ordre et le type des paramètres doivent correspondre
procédure appelée ou l'utiliser dans une expression. L'appel d'une  En pseudo-code, on va préciser explicitement le mode de transmission dans
procédure est une instruction autonome la déclaration de la procédure
67 68 69

Transmission des paramètres : exemples Transmission par valeur, par adresse : exemples Variables locales et globales (1)
Procédure incrementer1 (x : entier par valeur, y : entier par adresse) Procédure qui calcule la somme et le produit de deux entiers :  On peut manipuler 2 types de variables dans un module (procédure ou
x ← x+1 Procédure SommeProduit (x,y: entier par valeur, som, prod : entier par adresse) fonction) : des variables locales et des variables globales. Elles se
y ← y+1 som ← x+y distinguent par ce qu'on appelle leur portée (leur "champ de définition", leur
FinProcédure prod ← x*y "durée de vie")

Algorithme Test_incrementer1 FinProcédure

 Une variable locale n'est connue qu'à l'intérieur du module ou elle a été
variables n, m : entier
définie. Elle est créée à l'appel du module et détruite à la fin de son exécution
Début Procédure qui échange le contenu de deux variabales :
n← 3 Procédure Echange (x : réel par adresse, y : réel par adresse)
 Une variable globale est connue par l'ensemble des modules et le
m← 3 variables z : réel
programme principale. Elle est définie durant toute l’application et peut être
incrementer1(n, m) résultat : z←x utilisée et modifiée par les différents modules du programme
écrire (" n= ", n, " et m= ", m) n=3 et m=4 x←y
Fin y←z
FinProcédure
Remarque : l'instruction x ← x+1 n'a pas de sens avec un passage par valeur
70 71 72

8
 09/05/2014

Variables locales et globales (2) Exemple introductif

 La manière de distinguer la déclaration des variables locales et globales
diffère selon le langage
Algorithmique  Supposons qu'on veut conserver les notes d'une classe de 30 étudiants
pour extraire quelques informations. Par exemple : calcul du nombre
d'étudiants ayant une note supérieure à 10
• En général, les variables déclarées à l'intérieur d'une fonction ou  Le seul moyen dont nous disposons actuellement consiste à déclarer 30
procédure sont considérées comme variables locales variables, par exemple N1, …, N30. Après 30 instructions lire, on doit écrire
30 instructions Si pour faire le calcul
• En pseudo-code, on va adopter cette règle pour les variables locales et on
nbre ← 0
déclarera les variables globales dans le programme principale
Si (N1 >10) alors nbre ←nbre+1 FinSi
Les tableaux ….
• Conseil : Il faut utiliser autant que possible des variables locales plutôt que
des variables globales. Ceci permet d'économiser la mémoire et d'assurer Si (N30>10) alors nbre ←nbre+1 FinSi
l'indépendance de la procédure ou de la fonction c'est lourd à écrire
 Heureusement, les langages de programmation offrent la possibilité de
rassembler toutes ces variables dans une seule structure de donnée
appelée tableau
73 74 75

Tableaux Tableaux : remarques Tableaux : exemples (1)

 Un tableau est un ensemble d'éléments de même type désignés  L'accès à un élément du tableau se fait au moyen de l'indice. Par exemple,  Pour le calcul du nombre d'étudiants ayant une note supérieure à
par un identificateur unique notes[i] donne la valeur de l'élément i du tableau notes 10 avec les tableaux, on peut écrire :
 Une variable entière nommée indice permet d'indiquer la position  Selon les langages, le premier indice du tableau est soit 0, soit 1. Le plus
souvent c'est 0 (c'est ce qu'on va adopter en pseudo-code). Dans ce cas, Variables i ,nbre : entier
d'un élément donné au sein du tableau et de déterminer sa valeur
notes[i] désigne l'élément i+1 du tableau notes tableau notes[30] : réel
 La déclaration d'un tableau s'effectue en précisant le type de ses Début
 Il est possible de déclarer un tableau sans préciser au départ sa dimension.
éléments et sa dimension (le nombre de ses éléments) nbre ← 0
Cette précision est faite ultérieurement
•
.

En pseudo code : Pour i allant de 0 à 29

• Par exemple, quand on déclare un tableau comme paramètre d'une procédure, Si (notes[i] >10) alors
variable tableau identificateur[dimension] : type on peut ne préciser sa dimension qu'au moment de l'appel
nbre ←nbre+1
• Exemple :
• En tous cas, un tableau est inutilisable tant qu’on n’a pas précisé le nombre de FinSi
variable tableau notes[30] : réel ses éléments FinPour
 On peut définir des tableaux de tous types : tableaux d'entiers, de  Un grand avantage des tableaux est qu'on peut traiter les données qui y écrire ("le nombre de notes supérieures à 10 est : ", nbre)
réels, de caractères, de booléens, de chaînes de caractères, … sont stockées de façon simple en utilisant des boucles Fin
76 77 78

Tableaux : saisie et affichage Tableaux : exemples d'appel Tableaux : fonction longueur

 Procédures qui permettent de saisir et d'afficher les éléments d'un tableau :  Algorithme principale où on fait l'appel des procédures SaisieTab et La plus part des langages offrent une fonction longueur qui donne la dimension
AfficheTab : du tableau. Les procédures Saisie et Affiche peuvent être réécrites comme suit :
Procédure SaisieTab(n : entier par valeur, tableau T : réel par référence )
variable i: entier Procédure SaisieTab( tableau T : réel par référence )
variable i: entier
Pour i allant de 0 à n-1 Algorithme Tableaux
écrire ("Saisie de l'élément ", i + 1) Pour i allant de 0 à longueur(T)-1
variable p : entier écrire ("Saisie de l'élément ", i + 1)
lire (T[i] )
tableau A[10] : réel lire (T[i] )
FinPour
Début FinPour
Fin Procédure
p ← 10 Fin Procédure
Procédure AfficheTab(n : entier par valeur, tableau T : réel par valeur ) Procédure AfficheTab(tableau T : réel par valeur )
variable i: entier
SaisieTab(p, A)
variable i: entier
Pour i allant de 0 à n-1 AfficheTab(p,A)
Pour i allant de 0 à longueur(T)-1
écrire ("T[",i, "] =", T[i]) Fin écrire ("T[",i, "] =", T[i])
FinPour FinPour
Fin Procédure Fin Procédure
79 80 81

9
 09/05/2014

Tableaux à deux dimensions Exemples : lecture d'une matrice Exemples : affichage d'une matrice
 Les langages de programmation permettent de déclarer des  Procédure qui permet de saisir les éléments d'une matrice :  Procédure qui permet d'afficher les éléments d'une matrice :
tableaux dans lesquels les valeurs sont repérées par deux indices.
Procédure SaisieMatrice(n : entier par valeur, m : entier par valeur , Procédure AfficheMatrice(n : entier par valeur, m : entier par valeur
Ceci est utile par exemple pour représenter des matrices
tableau A : réel par référence ) ,tableau A : réel par
Début valeur )
 En pseudo code, un tableau à deux dimensions se déclare ainsi : variables i,j : entier Début
variable tableau identificateur[dimension1] [dimension2] : type Pour i allant de 0 à n-1 variables i,j : entier
écrire ("saisie de la ligne ", i + 1)
Pour i allant de 0 à n-1
• Exemple : une matrice A de 3 lignes et 4 colonnes dont les éléments Pour j allant de 0 à m-1
Pour j allant de 0 à m-1
sont réels écrire ("Entrez l'élément de la ligne ", i + 1, " et de la colonne ", j+1)
lire (A[i][j])
écrire ("A[",i, "] [",j,"]=", A[i][j])
variable tableau A[3][4] : réel FinPour
FinPour
FinPour FinPour
 A[i][j] permet d'accéder à l’élément de la matrice qui se trouve à
l’intersection de la ligne i et de la colonne j Fin Procédure Fin Procédure

82 83 84

Exemples : somme de deux matrices Appel des procédures définies sur les matrices Tableaux : Exemple d’exercice
 Procédure qui calcule la somme de deux matrices : Exemple d'algorithme principale où on fait l'appel des procédures définies
précédemment pour la saisie, l'affichage et la somme des matrices :
Procédure SommeMatrices(n, m : entier par valeur, Écrire l’algorithme du traitement qui permet de
tableau A, B : réel par valeur , tableau C : réel par référence ) Algorithme Matrices saisir 10 nombres entiers dans un tableau à
Début variables tableau M1[3][4],M2 [3][4],M3 [3][4] : réel une dimension, puis qui recherche et affiche la
variables i,j : entier Début valeur minimale entrée dans un tableau.
Pour i allant de 0 à n-1 SaisieMatrice(3, 4, M1) L’affichage mentionnera également l’indice
Pour j allant de 0 à m-1 SaisieMatrice(3, 4, M2) auquel se trouve ce minimum.
C[i][j] ← A[i][j]+B[i][j] AfficheMatrice(3,4, M1)
FinPour AfficheMatrice(3,4, M2)
FinPour SommeMatrice(3, 4, M1,M2,M3)
Fin Procédure AfficheMatrice(3,4, M3)
Fin
85 86 87

Algorithme recherche Mini

Recherche Mini
Variables
i, Indice_Mini, Mini : entiers
Tab(10) : tableau d’entiers
Début
pour i variant de 1 à 10
Lire Tab(i)
Fin de pour
Mini Tab(1)
Indice_Mini  1
pour i variant de 2 à 10
Si Tab(i) < Mini alors
Mini Tab(i)
Indice_Mini  i
Fin de Si
Fin de pour
ecrire (Mini, Indice_Mini)
Fin

88

10