Présentation Algo Cours 3

Cours: Algorithmique
LOYA Youssouf
youssouf.loya@u-auben.com
1
Objectif
Familiariser les étudiants avec les méthodes de
résolution de problèmes à l’aide de l’outil informatique.
A l’issue des enseignements, les étudiants devraient
être capables de :
 Maîtriser les notions de base de l’algorithmique;
 Spécifier un problème : identifier et organiser les
données d’entrée, de sortie et intermédiaires
Transcrire les différentes étapes de résolution d'un
problème sous forme d'algorithme, de façon
structurée et indépendante de toute contrainte
matérielle ou logicielle 2
Plan
 Notion d’algorithme
 Eléments de base d’un algorithme
 Structures de contrôle
Sous programmes
 Tableaux
3
4 – Sous-programmes
Notion de sous-programme
Définition d’un sous-programme
Appel d’un sous-programme
Passage de paramètres
Environnement d’un sous-programme
Sous-programme récursif
Modules
Conception des algorithmes
4
Notion de sous-programme
Motivation
Exemples introductifs, inconvénients et solutions
Exemple 1 : algorithme permettant un calcul d’aire de figures
ALGORITHME CalculerAires
CONST PI ← 3.1415927: REEL;
VAR choix ,rayon, largeur, longueur, cote : ENTIER;
aire : REEL;
DEBUT
(*demander la saisie de l’option choisie *)
ECRIRE ("Menu de calcul d’aires ");
ECRIRE ("====================== ");
ECRIRE ("1 : calculer l’aire d’un cercle ");
ECRIRE ("2 : calculer l’aire d’un rectangle ");
ECRIRE ("3 : calculer l’aire d’un carré ");
LIRE (choix);
(* selon le choix, effectuer le bon traitement *)
SUIVANT(choix ) FAIRE
1 : (*calculer l’aire d’un cercle *)
ECRIRE ("Quel est la rayon du cercle :");
LIRE (rayon);
aire ← 2 * PI * rayon;
ECRIRE ("l’aire du cercle : ", aire);
2 : (*calculer l’aire d’un rectangle *) 3 : (* calculer l’aire d’un carré *)
ECRIRE ("quel est la largeur :"); ECRIRE ("quel est le côté :");
LIRE (largeur); LIRE (cote);
ECRIRE ("quel est la longueur :");
LIRE (longueur); aire ← cote * cote;
ECRIRE ("l’aire du carré : ", aire);
aire ← largeur * longueur;
FINSVT
ECRIRE ("l’aire du rectangle : ", aire) FIN
5
Motivation
Exemples introductifs, inconvénients et solutions
Exemple 1 : algorithme permettant un calcul d’aire de figures
La structure générale de l’algorithme devient vite difficile à
appréhender au premier coup d’oeil…
Les calculs des aires d’un rectangle et d’un carré sont similaires et
sont des calculs bien connus : autant ne pas les récrire 2 fois
Exemple 2 : algorithme permettant le calcul du salaire net d’un
employé sachant:
Le salaire net = Salaire brut – Valeur de l’impôt – Valeur de CNSS
Salaire brut = (Salaire de base + Prime de technicité + Prime de transport + Prime des enfants) * Taux
de travail
Taux de travail = Nombre de jours travaillés /26
la prime des enfants est définie comme suit :
0 si le nombre d’enfants est 0,
16000 si le nombre d’enfants est strictement supérieur à 2.
Valeur de l’Impôt = Taux de l’Impôt * Salaire Brut
Valeur de CNSS = Taux de CNSS * Salaire Brut
Taux CNSS = 26,5%
Taux de l'impôt = 0 si le salaire de base < 150 000
Taux de l'impôt = 2% si le salaire de base [150000,250000[
Taux de l'impôt = 5% si le salaire de base [250000,500000[
Taux de l'impôt = 12% si le salaire de base >= 500 000. 6
Motivation
Exemples introductifs, inconvénients
Exemple 2 : algorithme permettant le calcul du salaire net d’un employé
ALGORITHME salaire
CONST TXCNSS  0.265: REEL;
TXIMP10: REEL;
TXIMP20.02: REEL;
PRIMEENF1  0: REEL;
PRIMEENF2  700: REEL;
PRIMEENF 3 12000: REEL;
PRIMEENF 4 16000: REEL;
BORIMP1150000: REEL;
BORIMP2250000: REEL;
BORIM3500000: REEL;
VAR nbenf, nbjr: ENTIER;
salbase, primetech, primetrans, salbrut, valcnss, valimp, primeenfs, tauxtr, salnet,
tximp: REEL;
DEBUT
(* 1. Calcul du salaire brut *)
(*1.1. Obtenir le salaire de base *)
ECRIRE(″Entrer le salaire de base de l’employé ″) ;
LIRE(salbase) ;
(*1.2. Obtenir la prime de technicité*)
ECRIRE(″Entrer la prime de technicité de l’employé ″) ;
LIRE(primetech) ;
(*1.3. Obtenir la prime de transport *)
ECRIRE("Entrer la prime de transport de l’employé ″);
LIRE(primetrans); 7
Motivation
(*1.4. calculer la prime des enfants*)
ECRIRE(″Entrer le nombre d’enfants de l’employé ″);
LIRE(nbenf);
ECRIRE("Entrer le nombre de jours travaillés de l’employé ″);
SI(nbenf=0) ALORS
primeenfs  PRIMEENF1 ;
SINON
SI(nbenf = 1) ALORS
SINON
SI(nbenf = 2) ALORS
SINON
primeenfs  PRIMEENF4;
FINSI
FINSI
FINSI
(*1.5. calculer le taux de travail*)
ECRIRE("Entrer le nombre de jours travaillés de l’employé ″);
LIRE(nbjr) ;
tauxtr  nbjr/26 ;
(*1.6. calculer le salaire brut*)
salbrut  (salbase + primetech + primetrans + primeenfs)*tauxtr;
8
Motivation
(* 2. Calcul du montant de l’impôt à partir du salaire brut *)
(*2.1. calculer le taux de l’impôt à partir du salaire de base*)
SI(salbase < BORIMP1) ALORS
tximpTXIMP1 ;
SINON
tximpTXIMP2 ;
SINON
tximpTXIMP3 ;
SINON
tximpTXIMP4 ;
FINSI
FINSI
FINSI
(*2.2. calculer le montant de l’impôt*)
valimp  salbrut * tximp;
(* 3. Calcul du montant de la CNSS à partir du salaire brut *)
valcnss  salbrut * TXCNSS ;
(* 4. Calcul du salaire net*)
salnet  salbrut – valcnss – valimp;
ECRIRE(″Le salaire net :″, salnet, ″FCFA″) ;
FIN
La structure générale de l’algorithme devient vite difficile à

appréhender au premier coup d’oeil… 9
Motivation
Exemple 3 :
ALGORITHME MonAlgo1
...
DEBUT
ECRIRE ("Ce programme est distribué sous licence CopyLeft.");
ECRIRE ("Vous pouvez le modifier à votre guise, MAIS ");
ECRIRE ("vous êtes dans l’obligation de le distribuer ");
ECRIRE ("sous licence CopyLeft.");
(* traitement effectué par l’algo 1*)
...
FIN
ALGORITHME MonAlgo2
...
DEBUT
(* traitement effectué par l’algo 2*)
...
FIN
Répétition d’un bloc d’actions autant de fois qu’il y a
d’algorithmes… 10
Motivation
Constats
Dans l’activité de programmation, on peut être confronté
aux cas suivants :
Des problèmes conduisant à des algorithmes longs,
difficiles à écrire et à comprendre;
les différentes parties de l’algorithme sont indépendantes
des séquences identiques d’instructions apparaissent en
plusieurs points de l'algorithme;
des séquences identiques d’instructions sont utilisées
dans d'autres algorithmes.
11
Motivation
Constats
Cela amène
un ralentissent de l’activité de développement
d’applications
des répétitions qui sont:
‒lourdes (on doit recopier les mêmes instructions à
plusieurs endroits)
‒dangereuses (bug du copier-coller)
‒causent de difficultés de lecture de l’algorithme
D’où la nécessité de regrouper des fois certaines
instructions en sous-programmes. 12
Motivation ECRIRE ("Menu de calcul d’aires ");
ECRIRE ("====================== ");
Constats ECRIRE ("1 : calculer l’aide d’un cercle ");
ALGORITHME CalculerAires ECRIRE ("2 : calculer l’aide d’un rectangle ");
.......... ECRIRE ("3 : calculer l’aide d’un carré ");
DEBUT LIRE (choix);
demander l’affichage du menu et la saisie de l’option choisie
(* selon le choix, effectuer le bon traitement *) (*calculer l’aire d’un cercle *)
SUIVANT(choix ) FAIRE ECRIRE ("Quel est la rayon du cercle :");
1: LIRE (rayon);
demander le calcul de l’aire du cercle aire ← 2 * PI * rayon;
2: ECRIRE ("l’aire du cercle : ", aire);
demander le calcul de l’aire du rectangle
3: (*calculer l’aire d’un rectangle *)
demander le calcul de l’aire du carré ECRIRE ("quel est la largeur :");
LIRE (largeur);
FINSVT ECRIRE ("quel est la longueur :");
FIN LIRE (longueur);
aire ← largeur * longueur;
ECRIRE ("l’aire du rectangle : ", aire)
(* calculer l’aire d’un carré *)

ECRIRE ("quel est le côté :");
LIRE (cote);
aire ← cote * cote;
ECRIRE ("l’aire du carré : ", aire);
13
Motivation
Constats
ALGORITHME MonAlgo1
...
DEBUT
demander l’exécution du bloc d’instructions
(* traitement effectué par l’algo 1 *)

...
FIN
ALGORITHME MonAlgo2
...
DEBUT
demander l’exécution du bloc d’instructions
(* traitement effectué par l’algo 2 *)

...
FIN
14
Définition
Un sous-programme est un ensemble d'instructions
nommé et éventuellement paramétré réalisant une tâche
précise.
Ecrire un sous-programme revient à donner à un
regroupement d’instructions un nom qui va désormais le
représenter dans la suite de l’algorithme.
Les sous-programmes permettent de réaliser des
abstractions procédurales.
,
15
Définition
Remarque:
Un sous-programme doit être homogène : il doit réaliser
une tâche précise, formant un tout.
Un sous-programme doit être de taille raisonnable
(autour de 20 ou 30 lignes) pour faciliter la
compréhension et la gestion de l’algorithme.
Les sous-programmes sont utilisés pour deux raisons
essentielles:
Pour éviter d’écrire plusieurs fois un même code.
Pour organiser le code, améliorer la conception et la
lisibilité des gros algorithmes. En effet, le découpage en
sous-programmes permet de traiter séparément les
difficultés. 16
Intérêt des sous-programmes
Les sous-programmes ont un rôle très important dans :
La structuration des algorithmes
Ils permettent de structurer l’algorithme en composants
fermés et cohérents;
Cela permet de faciliter la conception d’algorithmes
complexes;
L’analyse descendante par raffinements successifs divise
le problème en sous-problèmes cohérents; les sous-
programmes seront naturellement des outils adaptés à la
description de ces sous-problèmes. 17
La factorisation des calculs ou des traitements
Les instructions identiques apparaissant en plusieurs
endroits dans l’algorithme sont regroupées en un seul
endroit sous forme de sous-programme.
Cela conduit à un gain de place en mémoire pour le code
La réutilisabilité
Le fait de nommer un groupe d'instructions facilite leur
réutilisation dans un autre sous-programme sans
l'utilisateur ne sache comment ces instructions sont
écrites; de plus cela permet d'étendre le langage de base.
18
Le paramétrage des algorithmes
Certaines séquences d’instructions ont de fortes
ressemblances, et ne diffèrent par la valeur de certains
identificateurs ou expressions.
Le mécanisme de paramétrage d’un sous-programme
permettra de considérer une séquence d’instructions
comme un schéma de calcul abstrait dont les paramètres
représenteront des valeurs particulières à chaque
exécution de la séquence d’instructions. Le paramétrage
permet donc d’appliquer un sous-programme à des
contextes différents.
19
La compréhensibilité des algorithmes
Une conséquence de la structuration d’un algorithme à
l’aide des sous-programmes est l’augmentation de la
compréhension de l’algorithme, car l’algorithme est
découpé en sous-programmes de taille réduite qui sont
donc plus faciles à comprendre.
Les algorithmes font appel à des instructions de plus haut
niveau, les sous-programmes qui, de part leur nom
significatif, en améliore la compréhension.
La compréhension des sous-programmes facilite la
compréhension de la logique de l’algorithme principal.
20
La mise au point des algorithmes
Dès qu’un sous-programme est écrit, il est testé.
Ainsi, l’algorithme est testé sous-programme par sous-
programme c’est-à-dire petit morceau par petit morceau.
Les erreurs et surtout leurs origines sont alors beaucoup
plus facilement identifiées que si l’ensemble de
l’algorithme était testé d’un seul coup.
Le fait de pouvoir réutiliser un sous-programme dans
l’algorithme (plusieurs appels au sous-programme) et dans
d’autres algorithmes facilitent aussi l’écriture des
algorithmes. 21
L’amélioration de la maintenance des algorithmes
La structuration d’un algorithme à l’aide des sous-
programmes facilite la maintenance des algorithmes car
l’algorithme étant plus compréhensif, les points à modifier
ou à faire évoluer sont plus faciles à trouver.
La factorisation améliore également la maintenance car si
une modification est faite dans un sous-programme, elle
sera automatiquement prise en compte dans toutes les
autres parties qui utilisent ce sous-programme.
22
Types de sous-programmes
Fonction
La notion de fonction, en algorithme, modélise la notion
mathématique de fonction: à une valeur du paramètre x
choisie dans un ensemble de départ (le domaine de
définition de la fonction), on fait correspondre une valeur
f(x) appartenant à l'ensemble d'arrivée.
Ainsi, une fonction est un sous-programme qui exécute un
certain nombre d’instructions et qui renvoie une valeur de
retour au terme de son exécution.
Une fonction est un sous-programme de type expression:
son exécution fournit un résultat utilisable comme une
expression : affectation, affichage, autre expression.
23
Procédure
Une fonction retourne en résultat une valeur unique à
chaque exécution.
Que faire lorsqu’on a besoin de produire, dans un même
sous-programme, plusieurs résultats différents ? ou pas de
résultat du tout ?
Les procédures répondent à ce besoin, en autorisant
plusieurs genres de paramètres.
Une procédure est donc un sous-programme qui exécute
un certain nombre d’actions sans fournir de valeur de
retour après son exécution: tout se passe au niveau des
paramètres. 24
Procédure
Une procédure est un sous-programme de type instruction
(inutilisable dans une expression).
25
Définition d’un sous-programme
Définir un sous-programme, c’est associer un nom unique
à une suite d’instructions.
Le nom est l’identificateur du sous-programme .
La définition d’un sous-programme comporte trois parties
L’en-tête ou signature ou prototype qui spécifie:
Le type du sous-programme: fonction ou procédure.
Le nom du sous-programme ; il suit les mêmes règles que
celui d’une variable.
26
Les paramètres formels, leurs types et leurs statuts
Certains sous-programmes, pour pouvoir s'exécuter, ont
besoin qu'il leur soit communiqué des informations.
Au moment où on définit un sous-programme, on ne peut
pas savoir déjà avec quelles valeurs de chacune de ces
informations il va s'exécuter.
C'est pourquoi on utilise, pour chaque information, un
nom qui représente l'ensemble des valeurs possibles de
l'information que le sous-programme va recevoir.
Ce nom, c'est le paramètre formel ou muet.
27
Les paramètres formels, leurs types et leurs statuts
C’est une variable dont la valeur et l’adresse sont
connues à l’exécution.
Pour chaque paramètre, il faut indiquer son statut(E, S
ou E/S), son nom, et son type.
Les définitions des paramètres sont placées entre
parenthèses () et séparées par des virgules.
Le type du résultat dans le cas d’une fonction, précédé de
deux points (:)
28
La définition des données nécessaires à l’exécution de
la suite d’instructions.
Le corps
Il contient la suite d’instructions, c’est à dire la description
de ce que fait le sous-programme.
Pour les fonctions, le corps contiendra au moins une
instruction (RETOURNER) indiquant la valeur à retourner.
Le corps est délimité entre DEBUT et FIN
29
 Syntaxe
PROCEDURE <nom_procédure> ([<liste paramètres formels>])
[déclaration] Définition des données
DEBUT
< liste instruction> Corps En-tête
FIN
FONCTION < nom_fonction> ([<liste paramètres formels>]) : <type_résultat>

[déclaration] Définition des données
DEBUT
<liste instructions> Corps
FIN
30
 Exemples (* Procédure prenant deux entiers *)
PROCEDURE Equation1erdegre(a: REEL, b:REEL)
DEBUT
SI (a 0) ALORS
ECRIRE(La solution est :, -b/a) ;
SINON
SI( b = 0 )ALORS
ECRIRE(La solution est :, IR) ;
SINON
ECRIRE(Pas de solution) ;
FINSI
FINSI
FIN
(* Fonction prenant un réel et un entier *)
FONCTION puissance (x : REEL, n : ENTIER) : REEL (* puissance nième d’un réel x*)
VAR k : ENTIER;
resultat : REEL ;
DEBUT
resultat 1 ;
POUR k DE 1 A n FAIRE
résultat  résultat * x ;
FINPOUR
RETOURNER resultat ;
FIN 31
 Exemples
(* Procédure ne prenant pas de donnée*)
PROCEDURE message()
DEBUT
ECRIRE( Bonjour);
FIN
(* Fonction ne prenant pas de donnée et renvoyant un réel *)

FONCTION salaireBase() : REEL
VAR montant: REEL ;
DEBUT
ECRIRE( Entrer le salaire de base de l’employé:);
LIRE(montant);
RETOURNER montant;
FIN
32
Appel d’un sous-programme
L’appel d’un sous-programme est une instruction
élémentaire qui permet l’exécution de la suite d’instructions
associée à son nom
Il consiste simplement à indiquer le nom du sous-
programme avec éventuellement entre parenthèses et
séparés par des virgules ses paramètres effectifs.
Un paramètre effectif est la valeur fournie au paramètre
formel, au moment de l’appel du sous-programme, sous
forme de nom (variable) ou expression.
Un sous-programme peut être appelé soit dans
l’algorithme principal, soit dans un autre sous-programme.
(*Exemple*)
VAR p, a, b : RÉEL ;
LIRE(a, b);
Equation _du_premier_degre(a, b) ;
ppuissance (5.25, 4) ;
33
Appel d’un sous-programme
Les étapes de l’appel d’un sous-programme sont:
Enregistrement du contexte du sous-programme appelé ;
Débranchement vers le sous-programme appelé ;
Exécution du corps du sous-programme appelé ;
Retour du sous-programme appelé; après l’exécution du
corps du sous-programme appelé, celui-ci s’achève et la
prochaine instruction exécutée est celle qui suit
immédiatement l’appel du sous-programme dans le sous-
programme appelant Appelé
Appelant
[déclarations]
[déclarations]
DEBUT
DEBUT
................
...............
................
...............
FIN
FIN
34
Passage de paramètres
Dans les sous-programmes, on utilise deux types de
paramètres :
Les paramètres formels ou muets définissant les
données nécessaires au fonctionnement du sous-
programme, les valeurs attendues pour son
fonctionnement. Ils utilisés lors de la définition du sous-
programme.
Les paramètres effectifs ou réels correspondant aux
valeurs qui sont effectivement communiquées au sous-
programme au moment de son appel. Utilisés lors de
l’appel du sous-programme, ils fournissent la valeur des
paramètres formels à l’exécution.
35
Lors de l’appel d’un sous-programme, les paramètres
effectifs sont mis en correspondance avec les
paramètres formels, un à un et de gauche à droite avec
vérification des type des paramètres.
On impose que le nombre de paramètres effectifs soit
identique à celui des paramètres formels.
On appelle mode de passage (ou de transmission) de
paramètres effectifs, la manière dont les paramètres
effectifs sont associés aux paramètres formels.
C’est un mécanisme qui permet la communication des
informations entre l’algorithme appelant et le sous-
programme appelé.
Le mode de passage d’un paramètre réel dépend du statut
du paramètre formel lui correspondant. 36
Statut d’un paramètre formel
La paramétrisation permet de faire abstraction d'une
information pour décrire un algorithme.
Les paramètres sont classifiés selon l'abstraction qu'ils
représentent et la façon dont ils sont utilisés par les sous-
programmes.
Les différents statuts des paramètres formels
Paramètre donnée ou en entrée(E)
Un paramètre donnée est une abstraction de la valeur de
l'information considérée.
Il exprime que l'on désire uniquement consulter la valeur
de l'information.
Un paramètre donnée constitue en fait une donnée du
traitement réalisé par le sous-programme ; la valeur de
cette donnée est communiquée à l'appel, par le sous-
programme appelant. 37
Les différents statuts des paramètres
Paramètre donnée ou en entrée(E)
Les paramètres donnée sont définis en précédant le nom
du paramètre formel de la lettre E dans l’en-tête lors de la
définition du sous-programme. C’est le statut par défaut.
(*Exemple*)
FONCTION abs(E unEntier : ENTIER) : ENTIER (*calcule la valeur absolue d’un entier*)
DEBUT
SI (unEntier  0) ALORS
RETOURNER unEntier ;
SINON
RETOURNER - unEntier ;
FINSI
FIN
38
Paramètre résultat ou en sortie(S)
Un paramètre résultat est une abstraction du nom de
Il exprime que l'on désire uniquement construire (créer) la
valeur de l'information.
Le paramètre résultat est communiqué au programme
appelant au moment du retour d'appel, c'est-à-dire à la fin
du sous-programme.
La valeur du paramètre formel résultat est alors copiée
dans la variable passée en paramètre effectif dans l'appel.
39
La valeur initiale du paramètre effectif n'a aucune
importance ; elle est même souvent indéterminée. Le sous-
programme se charge de lui affecter une valeur.
Les paramètres résultat sont définis en précédant le nom
du paramètre formel de la lettre S dans l’en-tête lors de la
définition du sous-programme.
Exemple: Sous-programme donnant le minimum et le maximum de trois entiers.
Définissons d’abord les fonctions calculant respectivement le minimum et le
maximum de deux entiers
40
FONCTION minimum_deux (E a, b : ENTIER) :ENTIER
DÉBUT
SI (a  b) ALORS
RETOURNER b ;
SINON
RETOURNER a ;
FINSI
FIN
FONCTION maximum_deux (E a,b : ENTIER) :ENTIER
DÉBUT
SI (a  b) ALORS
RETOURNER a ;
SINON
RETOURNER b ;
FINSI
FIN
41
Définissons ensuite les fonctions calculant respectivement le minimum et le maximum de trois
entiers.
FONCTION minimum_trois (E a,b,c : ENTIER) :ENTIER
DÉBUT
RETOURNER minimum_deux (a , minimum_deux(b, c));
FIN
FONCTION maximum_trois (E a,b,c : ENTIER) :ENTIER
DÉBUT
RETOURNER maximum_deux (a , maximum_deux (b, c));
FIN
Définissons le sous-programme (procédure car plusieurs résultats) donnant le minimum et le
maximum de trois entiers
PROCÉDURE calculer MinMax(E a, b, c : ENTIER ; S min, max : ENTIER)
DÉBUT
min minimum_trois(a, b, c) ;
max maximum_trois(a, b, c) ;
FIN
VAR a, b, c, mi, ma: ENTIER;
LIRE(a, b, c);
calculerMinMax(a, b, c, mi, ma); ECRIRE(Minimum:, mi, Maximum:, ma); 42
Paramètre donnée/résultat ou en entrée/sortie(E/S)
Un paramètre donnée/résultat est une abstraction de
Il exprime que l'on désire modifier la valeur de l'information
en tenant éventuellement compte de sa valeur initiale.
Avant l’exécution des instructions du sous-programme, la
valeur du paramètre effectif est affectée au paramètre
formel;
Ensuite le sous-programme modifie éventuellement la
valeur du paramètre et retourne la nouvelle valeur du
paramètre à l'appelant à travers le paramètre effectif.
Les paramètres donnée/résultat sont définis en précédant
le nom du paramètre formel de la lettre E/S dans l’en-tête
lors de la définition du sous-programme.
43
Paramètre donnée/résultat ou en entrée/sortie(E/S)
Exemple: Sous-programme permettant d’échanger les valeurs de deux variables
PROCÉDURE echanger(E/S val1, val2:ENTIER)
VAR temp: ENTIER ;
DÉBUT
temp val1 ;
val1 val2 ;
val2temp ;
FIN
Remarque
Une fonction ne devra en principe comporter aucun
paramètre en sortie ou en Entrée/sortie puisque par
définition elle retourne un seul résultat dénoté par l’appel
de la fonction.
44
Sémantique des statuts de paramètre
Un paramètre effectif associé à un paramètre formel de
statut S ou de statut E/S est utilisé pour mémoriser l’effet
de l’appel du sous-programme. Donc il doit être une
variable de l’appelant.
Un paramètre effectif associé à un paramètre formel de
statut E est utilisé pour sa valeur uniquement. Donc il
peut être:
 la valeur d'une variable du programme appelant;
 une constante;
 le résultat du calcul d'une expression.
Les paramètres formels d’un sous-programme sont
toujours des variables : elles permettent de nommer les
informations d’entrée et/ou de sortie de l’appelant.
45
Sémantique des statuts de paramètre
Sous-programme appelant: paramètres effectifs
valeur variable variable
(1) (2)
Entrée Sortie Entrée/Sortie
variable variable variable
Sous-programme appelé: paramètres formels

46
Règles d'utilisation des paramètres formels
Un paramètre en entrée ne doit apparaître qu'en partie
droite d'une affectation (valeur du paramètre).
Un paramètre en sortie ne doit apparaître qu'en partie
gauche d'une affectation.
Un paramètre en entrée/sortie autorise des opérations de
consultation et de modification (parties gauche et droite
d'une affectation).
47
Modes de transmission de paramètre
Il existe essentiellement deux manières de passer des
paramètres effectifs à un sous-programme pour qu’il
puisse les manipuler au travers des paramètres formels.
Mode de passage par valeur
 Définition
Le mode de passage par valeur consiste à affecter au
paramètre formel la valeur du résultat de l’évaluation du
paramètre effectif lors de l'appel du sous-programme;
Le paramètre effectif sert donc à fournir une valeur initiale
au paramètre formel.
Pour spécifier ce mode de transmission, il suffit de déclarer
le paramètre formel correspondant en entrée. 48
 Propriétés
Lors de l'appel du sous-programme, il y a création d'un
emplacement local correspondant au paramètre formel
dans lequel est recopiée la valeur du paramètre effectif; au
retour du sous-programme, l'emplacement local est détruit.
Le paramètre effectif peut être une variable, une constante,
la valeur d'une fonction ou une expression quelconque.
Toute modification du paramètre formel reste locale au
sous-programme et n’affecte pas le paramètre effectif; le
passage par valeur protège donc le paramètre effectif
contre les effets de bord. 49
 Propriétés
Le mode de passage par valeur introduit un temps
supplémentaire au temps d’exécution du sous-programme
correspondant au temps de recopie du paramètre effectif.
Le mode de passage par valeur consomme de l’espace
mémoire car pendant l’exécution du sous-programme, le
paramètre effectif existe en deux exemplaires.
Ce mode de passage est déconseillé pour de grandes
structures de données.
50
Mode de passage par variable, adresse ou référence
 Définition
Le mode de passage par variable consiste à passer non
plus la valeur des variables comme paramètre, mais à
passer les variables elles-mêmes.
Le paramètre effectif est une variable, dont la valeur est
éventuellement utilisée par le sous-programme, puis
modifiée par le sous-programme.
Dans ce mode c'est en fait l’adresse en mémoire du
paramètre effectif qui est rendue accessible au sous-
programme, ce qui lui permet d'y lire et d'y écrire des
informations. 51
 Définition
Pour spécifier ce mode, il suffit de déclarer le paramètre
formel correspondant en sortie ou en entrée/sortie.
Propriétés
Le paramètre formel est une référence du paramètre
effectif c’est un autre nom du paramètre effectif, donc il n’y
a pas de copie du paramètre effectif.
Le paramètre effectif est nécessairement une variable.
Les modifications subies par le paramètre formel sont
transmises au paramètre effectif.
52
Propriétés
Le passage par variable est plus rapide et plus économe
en mémoire que le passage par valeur, puisque les étapes
de la création de la variable locale et la copie de la valeur
ne sont pas faites.
Paramètre formel à valeur par défaut
Les paramètres d’un sous-programme peuvent comporter
des valeurs par défaut qui seront utilisées si on n'en
transmet pas d'autres.
Concrètement, deux cas se présentent lors de l’appel :
On ne précise pas de valeurs pour les paramètres en
question: le sous-programme utilise celles par défaut.
On précise des valeurs: ce sont celles-ci qui sont utilisées.
53
Environnement d’un sous-programme
Structure générale d’un algorithme
ALGORITHME <nom_algo>
CONST - - - - - - - - - -
TYPE - - - - - - - - - - - -
VAR - - - - - - - - - - - -
sous-programme SP1
[Déclarations locales 1]
DÉBUT(* Début du corps du sous-programme SPS1*)
……………………....
FIN(* Fin du corps du sous-programme SPS1*)
sous-programme SP2 Définition des
Sous- programmes
[Déclarations locales 2]
DÉBUT(* Début du corps du sous-programme SPS2*)
……………………....
FIN(* Fin du corps du sous-programme SPS2*)
……………………........................................
DEBUT (* Début du corps de l’algorithme*)
-------------
FIN (* Fin du corps de l’algorithme*) 54
Structure générale d’un algorithme
ALGORITHME Test_Echange
VAR a, b : ENTIER ; (* a et b variables globales *)
PROCÉDURE echanger(E/S val1, val2: ENTIER)

VAR temp:entier ; (* temp variable locale*)
DÉBUT
tempval1 ;
val1val2 ;
val2temp ;
FIN
DÉBUT
ECRIRE(Entrer deux entiers :) ;
LIRE(a, b) ;
echanger(a, b) ;
ECRIRE(a = ,a, et b = , b) ;
FIN
55
Portée des objets
Objets globaux – Objets locaux
Tout objet (constante, type, variable ou sous-
programme) déclaré ou défini dans un sous-programme
est dit local. Les paramètres formels d’un sous-programme
sont des variables locales.
Un objet déclaré ou défini dans la partie déclaration de
l'algorithme principal est appelé objet global.
Portée d’un objet
La portée d’un objet est la région (partie) d’un algorithme
à l’intérieur de laquelle l’objet est connu, est utilisable.
La portée d’un objet commence après sa déclaration et se
termine avec l’entité ( algorithme, sous-programme) dans
laquelle il a été déclaré.
56
Portée des objets
Portée d’un objet
La portée d’un objet local est le sous-programme où il est
déclaré.
La portée d’un objet global est l’algorithme tout entier.
Masquage d’objet
Lorsque le nom d’une variable locale est identique à une
variable globale, la variable globale est localement
masquée ; dans ce sous-programme, la variable globale
devient inaccessible.
La visibilité d’un objet désigne la partie où il est accessible
(non masqué par une déclaration portant le même
identificateur).
La visibilité est plus petite ou égale à la portée. 57
Durée de vie d’un objet
La durée de vie d’un objet est la période durant laquelle
l’objet existe c’est-à-dire pendant laquelle elle peut être
utilisée.
Elle commence par la réservation de sa place en mémoire
et s’arrête lorsque cette place est libérée.
La durée de vie est liée à la portée.
La durée de vie d’un objet global est la durée nécessaire à
l’exécution de l’algorithme tout entier.
La durée de vie d’un objet local à un sous-programme est
la durée nécessaire à l’exécution du sous-programme : la
vie d’un objet local prend donc fin avec l’exécution du
sous-programme où il est déclaré. 58
Un sous-programme peut travailler :
sur des données du programme appelant (variables
globales); cette possibilité est cependant déconseillée;
sur des données transmises par l'appelant;
sur des données lui sont propres (variables locales);.
59
Communication entre sous-programmes
L’échange d’information entre un appelant (programme
principal, sous-programme) et un sous-programme appelé
peut se faire de deux façons:
Par les paramètres du sous programme appelé: Le sous-
programme appelé est alors assimilable à une boîte noire
dont l’effet ne dépend que de ses paramètres. Ceci
favorise la compréhension, l’évolution, la réutilisation.
Par les variables globales: cette méthode peut
conduire à des effets indésirables car les variables
globales sont des variables qui sont accessibles à la fois
de l’algorithme et de ses sous-programme (variables
partagées). Cette possibilité est donc déconseillée car:
60
Communication entre sous-programmes
Par les variables globales: Cette possibilité est
déconseillée car:
 elle limite la réutilisation : le sous-programme est très
dépendant de son contexte (les variables globales).
 elle rend la compréhension du programme difficile : le
passage des paramètres, l’appel au sous-programme
et la récupération des résultats se font en plusieurs
lignes pas forcément proches.
 elle rend l’algorithme difficile à maintenir car le résultat
d’un sous-programme ne dépend plus seulement de ses
paramètres mais également des valeurs des variables
globales qu’il utilise.
Modifier à un endroit la valeur d’une variable globale peut modifier
le comportement de plusieurs appels au sous-programme.
61
Résumé des effets de l’activation d’un sous-programme
Lors de l’appel d’un sous-programme, on a les étapes
suivantes :
Mise en correspondance des paramètres effectifs avec
les paramètres formels, un à un, de gauche à droite ;
Pour chaque paramètre formel en entrée : allocation d'un
emplacement et initialisation de l'emplacement par la
valeur du paramètre effectif (recopie) ;
Chaque paramètre formel en sortie ou en entrée/sortie
représente le paramètre effectif correspondant;
Pour chaque variable locale du sous-programme :
allocation d'un emplacement non initialisé; sa valeur est
indéterminée, il est nécessaire d'affecter une valeur dans
le corps du sous-programme 62
Résumé des effets de l’activation d’un sous-programme
Lors de l’appel d’un sous-programme, on a les étapes
suivantes :
Exécution du corps du sous-programme : pour les
paramètres en entrée et les variables locales, les
modifications sont temporaires. Pour les paramètres en
sortie et en entrée/sortie ainsi que pour les variables
globales, les modifications sont permanentes
A la fin de l'exécution du sous-programme (retour), tous
les emplacements créés sont libérés.
63
Sous-programme récursif
Définition
Un sous-programme est récursif s’il fait appel à lui-même
(récursivité directe) ou si ses instructions peuvent conduire
à un appel à lui-même (récursivité indirecte).
Exemple : Calcul de la factorielle d’un entier n.
FONCTION fact (E n: entier):ENTIER
DEBUT
SI (n = 0) ALORS
RETOURNER 1 ;
SINON
RETOURNER n*fact(n-1) ;
FINSI
FIN
64
Définition
Un sous-programme est récursif s’il fait appel à lui-même
(récursivité directe) ou si ses instructions peuvent conduire
à un appel à lui-même (récursivité indirecte).
Exemple : C(n, p)
Appel de sous-programme récursif
Chaque appel à un sous-programme donne naissance à
une activation qui doit mémoriser, entre autres, les
informations sur les valeurs de paramètres, l’adresse de
retour et les valeurs des objets locaux. Ces informations
sont collectées dans un enregistrement d’activation qui est
stocké dans un tableau appelé pile d’activation.
Lorsqu’un sous-programme est récursif, il peut exister
plusieurs activations du même sous-programme.
65
Exemple: l’appel fact(3) dans un programme.
L'ordinateur qui exécute le programme voit qu'on lui
demande de calculer fact(3). Il va en effet stocker dans la
pile le fait qu'on veut cette valeur, mais qu'on ne pourra la
calculer qu'après avoir obtenu la valeur de fact(2). On
procède ainsi (on dit qu'on empile les appels) jusqu'à
demander la valeur de fact(0) :
66
Exemple: l’appel fact(3) dans un programme.
Algorithme Début Début Début
Début
…………. ………… ……… ……..
…………..
Début 3*fact(2) ; 2*fact(1) ; 1;
1*fact(0) ;
…………. ………… ……… ……….
…………
fact (3) ; fin fin
fin fin
………….
fin 0 ?
1 ? 1 ?
2 ? 2 ? 2 ?
3 ? 3 ? 3 ? 3 ?
Arrivé au bout, il ne reste plus qu'à dépiler les appels, pour

de proche en proche pouvoir calculer la valeur de fact(3)
0 1
1 1
1 ?
2 ? 2 2
2 ? 3 6
3 ? 3 ?
3 ? 67
Règles d’écriture
Lors de la construction d’un sous-programme récursif, on
doit s’assurer que les points ci-dessous sont observés:
Le sous-programme doit être défini de manière
conditionnelle: quand il est appelé, il doit y avoir une
vérification d’une condition d'arrêt. Si elle est satisfaite,
la récursivité doit s'arrêter.
au moins l'un des cas de l'expression conditionnelle doit
mener à une expression évaluable sans appel récursif.
Chaque fois qu'il est appelé de manière récursive, un ou
plusieurs des arguments qui lui sont transmis doivent se
rapprocher de la condition d'arrêt.
le nombre d'appels récursifs pour parvenir à un résultat
doit être fini.
enfin, dans un sous-programme récursif, la complexité du
problème doit être réduite à chaque nouvel appel récursif.
68
Modules
Déclaration de sous-programme
PROCEDURE <nom_procédure> ([<liste paramètres formels>]);
FONCTION < nom_fonction> ([<liste paramètres formels>]) : <type_résul>;
Définition de module
Un module est un ensemble cohérent de sous-programmes
MODULE nom_module
INTERFACE
UTILISE ...
CONST ... Pour utiliser dans un algorithme, les sous -
TYPE ….. programmes d’un module, il faut le déclarer
VAR ...
Déclaration sp 1 à l’aide de la syntaxe:
………………… UTILISE nom_module ;
Déclaration sp n
IMPLEMENTATION
Définition sp 1
…………………
Définition sp n;
FIN 69
Conception des algorithmes
Comprendre l’énoncé du problème.
Décomposer le problème en sous problèmes plus simples
à résoudre. Représenter la décomposition:
Une boîte nommée par résolution de problème, avec:
• à gauche les types des données nécessaires à la
résolution du problème (informations en entrée)
• à droite les types des données résultats de la résolution
du problème(information en sortie)
Lorsqu'une résolution A0 a besoin d'une autre résolution
A1, la boîte décrivant la résolution A1 est dessinée en
dessous de la boite A0 et une flèche issue de la boîte A0
va jusqu‘à la boîte de A1.
70
Comprendre l’énoncé du problème.
Décomposer le problème en sous problèmes plus simples
Exemple: Afficher les nombres parfaits (nombres égaux à la
somme de leurs diviseurs) compris entre 1 et un nombre n (naturel1)
saisi par l’utilisateur
71
Associer à chaque sous problème, une spécification:
Les données nécessaires,
Les données résultantes,
La démarche à suivre pour arriver aux résultats en partant
d’un ensemble de données(logique de traitement).
Implémenter les sous-programmes répondants à la
spécification des différents sous problèmes
Coordonner le fonctionnement de tous les sous-
programmes développés dans un algorithme principal.
72

Présentation Algo Cours 3

Transféré par

Informations du document

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

Présentation Algo Cours 3

Transféré par

Droits d'auteur :

Formats disponibles

Cours: Algorithmique

 Eléments de base d’un algorithme

La structure générale de l’algorithme devient vite difficile à

(* calculer l’aire d’un carré *)

(* traitement effectué par l’algo 1 *)

(* traitement effectué par l’algo 2 *)

FONCTION < nom_fonction> ([<liste paramètres formels>]) : <type_résultat>

(* Fonction ne prenant pas de donnée et renvoyant un réel *)

valeur variable variable

variable variable variable

Sous-programme appelé: paramètres formels

PROCÉDURE echanger(E/S val1, val2: ENTIER)

Un sous-programme peut travailler :

sur des données du programme appelant (variables

globales); cette possibilité est cependant déconseillée;

sur des données transmises par l'appelant;

sur des données lui sont propres (variables locales);.

Arrivé au bout, il ne reste plus qu'à dépiler les appels, pour

Vous aimerez peut-être aussi