Vous êtes sur la page 1sur 53

Les sous-programmes

Objectifs
Le but est d'étudier la technique fondamentale des sous-
programmes. L'utilisation de sous-programmes facilite l'écriture
des gros programmes, permet la programmation en équipe et
améliore la qualité des programmes (notamment la lisibilité, la
réutilisabilité, et la maintenabilité). Elle procure donc des
économies importantes de programmation.
nous expliquons alors les points suivants:
◦ Le principe de base,
◦ Le passage de paramètres par adresse,
◦ Le passage de paramètres par valeur,
◦ Les variables locales,
◦ Un exemple complet récapitulant les notions vues,
◦ La technique de trace d'exécution avec des sous-programmes,
◦ La récursivité,
◦ Les sous-programmes externes,
◦ Les fonctions.
PRINCIPES DE BASE
Action ÉcartMoment
Var
HH,MM,SS,S1, S2,Diff : numérique
Début
Sortir "Donnez-moi un nombre d'heures"
Entrer HH
Sortir "Donnez-moi un nombre de minutes"
Entrer MM
Sortir "Donnez-moi un nombre de secondes"
Entrer SS
S1 : = HH*3600 + MM*60 + SS
Sortir "Donnez-moi un nombre d'heures"
Entrer HH
Sortir "Donnez-moi un nombre de minutes"
Entrer MM
Sortir "Donnez-moi un nombre de secondes"
Entrer SS
S2 := HH*3600 + MM*60 + SS
Si S1>S2 Alors
Diff := S1 - S2
Sinon
Diff := S2 – S1
Fsi
Sortir "La différence entre ces deux moments est ", Diff, "secondes."
FinAction
Introduction du sous-programme
EntrerHeure dans l'algorithme EcartMoment
Action EcartMoment
Var HH, MM, SS : numérique Définition du sous-programme EntrerHeure
S1, S2, Diff : numérique
Action EntrerHeure
Sortir "Donnez-moi un nombre d'heures"
Entrer HH
Sortir "Donnez-moi un nombre de minutes"
Entrer MM
Sortir "Donnez-moi un nombre de secondes"
Entrer SS
FinAction
Début
EntrerHeure  1er appel de EntrerHeure
S1 := HH*3600 + MM*60 + SS
EntrerHeure  2ème appel de EntrerHeure
S2 := HH*3600 + MM*60 + SS
Si S1 >S2 Alors
Diff := S1 - S2
Sinon
Diff := S2 – S1
Fsi
Sortir "La différence entre ces deux moments est ", Diff, "secondes."
FinAction
Fonctionnement
L'exécution d'un algorithme contenant des appels de
sous-programmes suit la règle fondamentale de
toute exécution d'algorithme, exécuter les
instructions les unes après les autres dans l'ordre où
elles sont écrites, à ceci près :
 Lorsqu'un appel à un sous-programme est
rencontré, l'exécution en séquence s'arrête et se
poursuit à la première instruction du sous-
programme. On dit qu'elle se débranche au
sous-programme appelé.
 En fin d'une exécution du sous-programme, elle
revient automatiquement à l'instruction qui
suit la ligne de l'appel, et reprend son exécution en
séquence.
Notez bien
Il est capital de distinguer les deux aspects de
l'algorithme EntrerHeure. D'une part sa
définition, c'est-à-dire sa programmation, et
d'autre part ses appels, c'est-à- dire ses
utilisations dans l'algorithme ÉcartMoment. Un
algorithme dont l'utilisation est conçue en
deux parties :
◦ DÉFINITION
◦ APPEL(S)
Sous-programmes en série
Action ÉcartMoment Par simplification, la définition de ce
Var HH, MM, SS : numérique sous-programme n'est pas rappelée ici.
S1, S2, Diff : numérique Se reporter à l'endroit indiqué.
Action EntrerHeure : voir AVANT.
Action Différence
Si S1 >S2 alors Définition d'un second sous-programme :
Diff := S1 - S2 Différence.
Sinon
Diff := S2 – S1
Fsi
Sortir"La différence entre ces deux moments"," est",Diff,"secondes"
FinAction
Début
EntrerHeure L'appel au sous-programme Différence
S1 := HH*3600 + MM*60 + SS permet de réduire encore la taille du
EntrerHeure programme.
S2 := HH*3600+ MM*60 + SS
Différence
FinAction
Sous-programmes de sous-
programme
Action EntrerHeure
Action Entrer1
Sortir "Donnez-moi un nombre d'heures”
Entrer HH
FinAction
Action Entrer2
Sortir "Donnez-moi un nombre de minutes"
Entrer MM
FinAction
Action Entrer3
Sortir "Donnez-moi un nombre de secondes"
Entrer SS
FinAction
Début
Entrer1
Entrer2
Entrer3
FinAction
Imbrication d'écritures des sous-
programmes
Cette possibilité de sous-programme de
sous-programme n'a pas de limites. Un
programme P0 peut posséder un sous-
programme P1, qui peut lui-même posséder
un sous-programme P2, qui peut lui- même
posséder un sous-programme P3, etc. On dit
Action P0
que : Action P1
P3 appartient à P2, Action P2
Action P3
P2 appartient à P1, Programmation de P3
P1 appartient à P0. Programmation de P2
Programmation de P1
Programmation de P0
Imbrication d'écritures des sous-
programmes
Le premier programme, ici P0, est appelé programme
principal ou encore programme racine.
Lorsqu'un programme possède un sous-programme, le
programme est dénommé le programme père et le
sous-programme, le programme fils.
Deux programmes fils, d'un même programme père, sont
programmes frères.
Action P0
Action P1
Action P2
Action P3
Programmation de P3
Programmation de P2
Programmation de P1
Programmation de P0
Profondeur d'écriture
on définir la notion de profondeur d'écriture d'un sous-
programme à l'aide des deux règles suivantes :
 Le programme racine est de profondeur 0,
 Un programme fils a la profondeur de son programme père plus
1.
Dans l'exemple :
 P0 est de profondeur 0,
 P1 est de profondeur 1,
 P2 est de profondeur 2,
 Et le sous-programme P3 est de profondeur 3.
Action P0 programme racine (profondeur 0) }
Action P1 {Sous-programme (profondeur 1) }
Action P2 {Sous-programme (profondeur 2) }
Action P3 { Sous-programme (profondeur 3) }
Programmation de P3
Programmation de P2
Programmation de P1
Programmation de P0
Arbre des écritures
Un arbre est un graphique construit à l'aide de points appelés nœuds et
de lignes, appelées branches, reliant ces nœuds. L'élément contenant est
placé au-dessus de l'élément contenu, le premier est appelé le nœud père
et le second le nœud fils. Deux nœuds fils d'un même nœud père sont
appelés nœuds frères.
L'arbre de la figure modélise les imbrications d'écritures entre les douze
programmes et sous-programmes P0 à P11, nous voyons immédiatement
que :
 P0 contient quatre sous-programmes : P0, P2, P3, P4,
 P2 contient trois sous-programmes : P5, P6 et P7,
 P7 contient deux sous-programmes : P9 et P10,
 P4 contient un seul sous-programme : P8,
 P8 contient un seul sous-programme : P11,
 P1, P3, P5, P6, P9, P10, et P11 ne contiennent
aucun sous-programme.
Contraintes sur les appels et les
noms
Un sous-programme ne peut appeler qu'une
partie de sa famille. Plus précisément comme
le schématisent les flèches de la figure
(flèches partant du sous-programme P7), il
peut appeler uniquement :
 Un fils,
 Un frère,
 Un ancêtre,
 Ou lui-même.
PASSAGE DE PARAMETRES
 Les variables déclarées dans le programme racine permettent
aux sous- programmes de communiquer entre eux. C'est
d'ailleurs, à ce stade des explications, la seule voie de
communication entre le programme appelant et le sous-
programme appelé.
 Cette communication entre programme et sous-programmes,
si elle est facile à comprendre et simple à utiliser, oblige le
concepteur dès le début de son projet, à :
◦ Déclarer dans le programme racine toutes les variables
nécessaires à l'ensemble des sous-programmes,
◦ Définir précisément l'utilisation de toutes ces variables
entre les sous- programmes, car il faut éviter qu'un sous-
programme ne vienne effacer les résultats produits par un
autre sous-programme.
Action ÉcartMoment
Var Heure1, Minute1, Seconde1 : numérique
Heure2, Minute2, Seconde2 : numérique
PASSAGE DE
S1, S2 : numérique PARAMETRES
Diff : numérique
Action Différence PAR ADRESSE
Si S1 >S2 alors
Diff := S1 - S2 Liste des noms provisoires, ici
Sinon Heure, Minute et Seconde.
Diff := S2 – S1
Fsi
Sortir"La différence entre ces deux moments est",Diff,"secondes"
FinAction
Action EntrerHeure( Var Heure : numérique; Var Minute : numérique; Var Seconde : numérique)
Sortir "Donnez-moi un nombre d'heures :"
Entrer Heure
Sortir "Donnez-moi un nombre de minutes :" Premier appel avec comme noms
Entrer Minute
Sortir "Donnez-moi un nombre de secondes :" réels : Heure1, Minute1 et Seconde1.
Entrer Seconde
FinAction
Deuxième appel avec comme
Début
EntrerHeure(Heure1, Minute1, Seconde1) noms réels : Heure2, Minute2 et
S1 := Heure1*3600 + Minute1*60 + Seconde1 Seconde2
EntrerHeure(Heure2, Minute2, Seconde2 )
S2 := Heure2*3600 + Minute2*60 + Seconde2
Différence
FinAction
Vocabulaire
 Les variables Heure, Minute, Seconde sont
appelées les paramètres formels du sous-
programme EntrerHeure.
 Dans le premier appel EntrerHeure(Heure1,
Minute1, Seconde1) les variables Heure1,
Minute1 et Seconde1, qui se substituent aux
variables Heure, Minute, Seconde, sont
appelées paramètres effectifs ou
arguments de l'appel. Les paramètres
effectifs du second appel sont Heure2,
Minute2 et Seconde2.
Vocabulaire
La substitution des paramètres formels par les paramètres
effectifs, réalisée automatiquement à chaque appel d'un
sous-programme, s'appelle le passage de paramètres. Cette
substitution possède, en Lap, deux modalités. Celle étudiée
dans ce paragraphe est appelée passage de paramètres par
adresse, l'autre est appelée passage de paramètres par
valeur. À chaque fois que, dans l'en-tête de définition du
sous-programme, un paramètre est précédé du mot-clé Var,
c'est la modalité par adresse qui est mise en œuvre pour ce
paramètre, lors des appels. À chaque fois que, dans l'en-tête
de définition du sous-programme, un paramètre n'est pas
précédé du mot-clé Var, c'est la modalité par valeur qui est
mise en œuvre pour ce paramètre, lors des appels.
Concordance entre paramètres
effectifs et paramètres formels
 Pour un bon fonctionnement, le nombre
de paramètres effectifs doit toujours
être égal au nombre de paramètres
formels, sinon il y a erreur d'exécution et
arrêt brutal de l'exécution.
 De même, les types des paramètres
effectifs doivent correspondre,
paramètre par paramètre, à ceux des
paramètres formels. sinon il y a erreur
d'exécution et donc arrêt brutal de
l'exécution
Noms des paramètres effectifs,
noms des paramètres formels
Les noms des paramètres formels, utilisés dans
l'écriture des sous-programmes, et ceux des
paramètres effectifs, utilisés lors des appels dans le
programme principal, peuvent être des noms
différents. De même, il est possible qu'un même sous-
programme soit appelé plusieurs fois en travaillant
avec des paramètres effectifs différents d'un appel à
l'autre, seules les positions des paramètres effectifs
lors de l'appel sont prises en compte
Bien entendu, ce n'est pas obligatoire, les noms des
paramètres effectifs peuvent être identiques aux noms
des paramètres formels, le mécanisme reste le même
PASSAGE DE PARAMÈTRES PAR
VALEUR
Du point de vue du sous-programme, il
existe deux types de flux de communication
d'informations :
◦ L'utilisation de valeurs fournies par le programme
principal.
◦ La transmission de résultats vers le programme
principal.
 Ce flux de communication peut se faire en
utilisant soit la technique des variables
globales soit en utilisant la technique des
paramètres.
Action ÉcartMoment
Var Heure1, Minute1, Seconde1 : numérique
Heure2, Minute2, Seconde2 : numérique PASSAGE DE
S1, S2 : numérique PARAMETRES
Diff : numérique
Action Différence,
Si S1 >S2 alors
Diff := S1 - S2 Liste des noms provisoires, ici
Sinon Heure, Minute et Seconde.
Diff := S2 – S1
Fsi
Sortir"La différence entre ces deux moments"," est",Diff,"secondes"
FinAction
Action EntrerHeure( Var Heure : numérique; Var Minute : numérique; Var Seconde : numérique)
Sortir "Donnez-moi un nombre d'heures :"
Entrer Heure
Sortir "Donnez-moi un nombre de minutes :" Premier appel avec comme noms
Entrer Minute
Sortir "Donnez-moi un nombre de secondes :" réels : Heure1, Minute1 et Seconde1.
Entrer Seconde
FinAction
Deuxième appel avec comme
Début
EntrerHeure(Heure1, Minute1, Seconde1) noms réels : Heure2, Minute2 et
S1 := Heure1*3600 + Minute1*60 + Seconde1 Seconde2
EntrerHeure(Heure2, Minute2, Seconde2 )
S2 := Heure2*3600 + Minute2*60 + Seconde2
Différence
FinAction
Passage par valeur
Dans le cas d'un paramètre en entrée, la
variable passée en paramètre n'est pas
modifiée par l'exécution du sous-
programme. La valeur mémorisée par cette
variable est la même avant et après l'appel.
On peut conclure que le sous- programme
n'a besoin que de la valeur de la variable
passée en paramètre effectif
Passage par valeur
Quel que soit le mode de passage de
paramètres, la correspondance entre les
paramètres effectifs et les paramètres
formels se fait toujours en tenant compte
uniquement de l’ordre des paramètres, la
différence de communication entre les
modes de passage n'est pas là.
Action PrincipalXYZ
Var Ch, Car : Chaîne de caractères
Position : numérique
{Définition du sous-programme}
Exemple
{Alphabetlnverse met dans Car la lettre de l'alphabet dont le numéro d'ordre est 27-Position}
Action Alphabetlnverse (Position : numérique ; Var Lettre : chaîne de caractères)
Début
{Ajustement si nécessaire de la valeur de Position passée en paramètre}
Si Position < 1 Alors
Position := 1
Fsi
Si Position >26 Alors
Position := 26
Fsi
{Mise dans Lettre du caractère adéquat}
Position : = 27 - Position {1 donnera 26 ; 2 donnera 25,... ; 26 donnera 1}
Lettre := SChain("abcdefghijklmnopqrstuvwxyz", Position, 1)
FinAction
{Début du programme principal}
Début
Ch :=""
Position: =1
{Concaténation du caractère "z" à la chaîne vide}
AlphabetInverse(Position, Car)
Ch := Ch+Car
{Concaténation du caractère "y" à la chaîne "z" }
Position := 2
AlphabetInverse(Position, Car)
Ch := Ch+Car
{Concaténation du caractère "x" à la chaîne " zy"}
Position := 3
AlphabetInverse(Position, Car)
Ch := Ch+Car
Sortir Ch
FinAction
Variable locales
 Une variable déclarée localement n'existe que
pendant l'exécution du sous-programme et ne
sert qu’a ce sous-programme.
 Le programme principal n'a jamais accès à une
variable locale du sous-programme.
 Un sous-programme n'a jamais accès a une variable
locale d'un autre sous-programme
 Les variables déclarées dans le VAR du programme
principal sont appelées variables globales. Elles
existent pendant toute la durée du programme et
sont accessible de partout.
 Une variable locale à un sous-programme P, portant
le même nom x qu'une variable globale, masque la
variable globale pendant l'exécution de P.
Sous-programme et variables locales
Action ÉcartMoment
Var HH, MM, SS: numérique
S1, S2: numérique Déplacement de la déclaration de la variable
Action Différence
Diff, elle est devenue une variable locale au
Var Diff : numérique
sous-programme Différence.
Début
Si S1 >S2 Alors
Diff := S1 - S2
Sinon
Diff := S2 – S1
Fsi
Sortir "La différence entre ces deux moments est", Diff, "secondes"
FinAction
Début
EntrerHeure
S1 := HH*3600 + MM*60 + SS
EntrerHeure
S2 := HH*3600 + MM%0 +SS
Différence
FinAction
FONCTIONNEMENT DE
VARIABLE LOCALES
 A chaque appel d'un sous-programme, le système
crée les variables locales du sous-programme, c'est-à-
dire affecte un emplacement de mémoire centrale
pour chacune des variables locales déclarées. Cet
emplacement mémoire n'est pas initialisé,
contrairement à une transmission par valeur par
exemple
 Durant toute la durée de l'appel, c'est-à-dire tant que
l'exécution n'a pas atteint le mot-clé FinAction du sous-
programme, le sous-programme et les sous- sous-
programmes de celui-ci peuvent utiliser ces variables
locales.
 En fin d'appel, toutes les variables locales créées en
début d'appel sont détruites.
Contraintes sur les noms
Une variable locale ne peut avoir le même
nom qu'un paramètre formel.
Action Ambiguë(Var Texte : chaîne de caractères;
Position : numérique )
Var
Texte : chaîne de caractères
Position : numérique
Début
Entrer Texte, Position
{Dans quelles variables Texte et Position !?}
Texte := SChain(Texte, Position, Position)
{Même remarque)
Programmation ambiguë et interdite
FinAction
Levée d'ambiguïté entre variables
locales et paramètres formels
Action NonAmbiguë(Var Texte : chaîne de caractères;
Position : numérique )
{Extraction d'un texte à partir de : un texte lu,
une position (transmise en paramètre) et une
longueur lue}
Var
WTexte : chaîne de caractères
WLongueur : numérique
Début
Entrer WTexte, WLongeur
Texte := SChain(WTexte, Position, WLongueur)
FinAction
Variables accessibles et variables
globales
 L'ensemble des variables accessibles à un
appel de sous-programme correspond à
l'ensemble des variables que le sous-
programme peut utiliser. Cette notion de
variable accessible est une notion
d'exécution et se détermine donc par
rapport à l'arbre des appels.
 Les endroits, programmes ou sous-
programmes, où une variable est accessible
s'appelle la portée de la variable
Ordre de priorité des variables
apparaissant dans un sous-programme
Lors de l'utilisation d'un nom de variable par un sous-
programme, il faut d'abord examiner si cette variable est une
variable locale, ensuite si c’est un paramètre formel et enfin,
si c'est une variable globale. Dans le cas où, elle serait à la
fois une variable locale et un paramètre formel, il y aurait
lieu de déclarer une erreur d'écriture. De même, si la variable
ne se trouve dans aucune des trois catégories citées.
Notez bien
 Une variable locale peut avoir le même
nom qu’une variable globale, et dans ce
cas, le sous-programme utilise la variable
locale. On dit que la variable locale
"l'emporte" sur la variable globale. Chaque
fois que le sous-programme modifie ou
consulte la valeur d'une telle variable il le fait
sur la variable locale et ignore la variable
globale.
 Une variable locale peut également avoir
le même nom qu'un paramètre effectif.
C'est un cas particulier du précédent. En effet,
un paramétré effectif est forcément une
variable globale du programme appelant
Exemple
L'algorithme entre une chaîne de caractères et sort le
nombre de voyelles contenues dans celle-ci.
Pour cela il utilise le sous-programme
DétectVoyelle(Caractère : chaîne de caractères, Var
Réponse : numérique) qui met 0 dans Réponse si Caractère
n'est pas une voyelle et 1 dans le cas contraire.
Dans cet algorithme, l'utilisation du nom de variable
CarCour est intéressante, car ce nom est utilisé à trois
titres :
1. pour désigner une variable locale du sous-
programme,
2. pour désigner une variable globale de l'algorithme
principal
3. comme paramètre effectif lors de l'appel
DetectVoyelle(CarCour, Réponse ).
Action Comptage
Var Le nom I est utilisé deux fois :
Texte, CarCour : chaîne de caractères une fois pour désigner une
NbVoyelles, I, Réponse : numérique
variable globale et une autre
{Le sous-programme}
fois pour désigner une variable
Procédure DétectVoyelle( Caractère : chaîne de caractères;
locale. Attention, à l’exécution
Var Réponse : numérique)
il y a existence de deux
Var
Voyelles, CarCour : chaîne de caractères variables
I: numérique
Début
Si Long(Caractère) <>1 Alors
Réponse : = 0
Sinon
Voyelles := "aeiouyAEIOUY"
I :=0
Réponse := 0
TantQue I <Long(Voyelles) Et Réponse = 0 Faire
I := I +1
CarCour : = Schain(Voyelles, I,1)
Si CarCour = Caractère Alors
Réponse := 1
Fsi
FTantQue
Fsi
FinProcédure
{Le sous-programme}
Début
suite La variable CarCour est utilisée comme
paramètre effectif et comme variable
{Le programme principal} locale de DétectVoyelle. Le paramètre
effectif est manipulé par le sous-
Début programme uniquement à travers le
paramètre formel correspondant :
Entrer Texte Caractère.
Nb Voyelles := 0
Pour I allant de 1 à Long(Texte) Faire
CarCour : = SChain(Texte, I,1)
DetectVoyelle(CarCour, Réponse)
NbVoyelles := NbVoyelles + Réponse
FPour
Sortir NbVoyelles
Fin Action
LA RÉCURSIVITÉ
Dans la plupart des langages de programmation,
il est permis qu'un sous- programme s'appelle
lui-même. Cette technique s'appelle la
récursivité.
Cet appel peut être direct, par exemple si P2
contient en son sein un appel à P2 ou indirect si
P2 appelle P3 qui appelle P2.
Il n'y a pas de limite quant à la longueur de la
chaîne des appels, par exemple, on peut avoir :
P2 appelle P3, P3 appelle P4, P4 appelle P5,...,
P18 appelle P19 et P19 appelle P2..
Programmation récursive de la
fonction mathématique Factorielle
Procédure Factorielle (N : numérique;
Var Résultat : numérique)
{Provisoire mémorise Factorielle de N-1 calculé
par un appel récursif à Factorielle}
Var
Provisoire : numérique
Début
Si N =1 Alors
Résultat := 1
Sinon
Factorielle (N - 1, Provisoire)
Résultat : = N * Provisoire
Fsi
FinProcédure
État en fin de trace d'exécution de
Factoridle(4, X)
X : 24
Factorielle(N=4, Résultat=X) Premier appel
N:4
Provisoire : 6
Factorielle(N=N-1=3, Résultat=Provisoire) Deuxième appel
N:3
Provisoire : 2
Factorielle(N=N-1=2, Résultat=Provisoire) Troisième
N:2
Provisoire : 1
Factorielle(N=N-1=1, Résultat=Provisoire) Quatrième
N:1 {la variable locale Provisoire n'est pas
Provisoire : utilisée par ce dernier appel}
Programmation récursive de
CompteBlancs
L'algorithme CompteBlancs réalise ce traitement
sans utiliser d'instruction répétitive mais grâce à
une programmation récursive.
L'idée est de dire que le nombre de caractères
blancs de la chaîne vide est égal à zéro, ce qui est
évident. Ensuite, que le nombre de caractères
blancs d'une chaîne différente de la chaîne vide est
égal au nombre de caractères blancs de son
premier caractère, plus le nombre de caractères
blancs contenus dans la chaîne amputée de son
premier caractère.
Programmation récursive du
comptage du nombre de caractères
blancs d'une chaîne de caractères

Voir le livre Page: 139


SOUS-PROGRAMME EXTERNE
Il existe une phase intermédiaire
entre la fin de l'écriture d'un
programme et son exécution.
Cette phase intermédiaire
éventuelle s'appelle la compilation
et consiste à analyser le programme
pour :
1. Détecter les erreurs de syntaxe,
2. Produire une traduction du
programme initial en
instructions machine.
COMPILATION SÉPARÉE ET
EDITEUR DE LIEN
Le programme initial est appelé le programme source et le
programme produit, écrit en instructions machine, est appelé
le programme exécutable.
Cependant afin de permettre de mieux travailler en équipe, et
accessoirement de ne pas avoir de trop gros programmes à
compiler, la plupart des outils de développement permettent la
compilation séparée. C'est-à-dire la possibilité de mémoriser
des sous-programmes dans des fichiers physiquement séparés
et de les compiler à part.
Dans ce système, il existe alors une phase supplémentaire,
l'édition de liens, qui consiste, à "assembler" toutes les
compilations des sous-programmes pour former le programme
exécutable final.
SOUS-PROGRAMME EXTERNE
Lorsque deux sous-programmes sont compilés
séparément ils ne peuvent avoir de variables
globales communes.
Toutes leurs communications de données doivent
se faire exclusivement via les paramètres ou des
fichiers.
En pratique la compilation séparée est utilisée
pour se constituer des bibliothèques de sous-
programmes. Le programmeur dispose alors de
centaines de procédures toutes faites qui lui
facilitent la tâche de programmation.
LES FONCTIONS
 La technique des fonctions consiste à "sortir", en
fin d'exécution du sous-programme, une valeur
par l'instruction spéciale Retourner.
 lorsque le Lap exécute un tel sous- programme, il
remplace dans le programme principal l'écriture
de l'appel par la valeur retournée.
 pour transformer un sous-programme en fonction
il faut remplacer le mot-clé Action, qui débute le
sous-programme par le mot-clé Fonction puis
ensuite, faire suivre l'en-tête de définition par le
symbole deux- noints (:) suivi du type de la
donnée
Exemple
Fonction DétectVoyelle (Caractère : chaîne de caractères) : numérique
Var
Voyelles, CarCour : chaîne de caractères
I, Verdict : numérique
Début
Si Long(Caractère) <> 1 Alors
Verdict :=0
Sinon
Voyelles := "aeiouyAEIOUY"
Verdict := 0
Pour I allant de 1 à Long(Voyelles) Faire
CarCour := SChain(Voyeües, 1,1)
Si CarCour = Caractère Alors
Verdict := 1
Fsi
FPour
Fsi
Retourner Verdict
FinFonction
Exemple (suite)
Action Comptage
Var
Texte, CarCour : chaîne de caractères
NbVoyelles, I : numérique
Fonction DétectVoyelle (Caractère : chaîne de caractères) : numérique
…….
Début
Voir SLIDE précédent
Entrer Texte
NbVoyelles : = 0
Pour I allant de 1 à Long(Texte) Faire
CarCour := SChain(Texte, 1,1)
NbVoyelles := NbVoyelles + DétectVoyelle(CarCour)
FPour
Sortir NbVoyelles
FinAction
EXERCICES
EXERCICE 1
Paramétrer le sous-programme Différence
(figure 7.3) de l’algorithme ÉcartMoment
(figure 7.9).
Exercice 2
Écrire un sous-programme HeurSec à deux
paramètres HeurSec(hh : numérique; Var ss :
numérique) où hh mémorise une heure sous la
forme heures, minutes, secondes et HeurSec
calcule dans ss l'équivalent en secondes de hh. Le
sous-programme acceptera la valeur de hh telle
quelle, sans faire de vérification. Exemples :
HeurSec(102030, ss) donne à ss la valeur 37230
et HeurSec(2030, ss) donne à ss la valeur 1230.

P151
Exercice 3
Écrire le sous-programme Détruire à trois paramètres :
Détruire(Var Ch : chaîne de caractères; Pos, Num :
numérique) qui supprime dans Ch la sous-chaîne
commençant à la position Pos sur une longueur de
Num. Cependant si Pos<1, Pos>Long(Ch) ou
Num<=0 alors aucune action n'est réalisée et Ch
demeure inchangée. Et si Pos+Num>Long(Ch) alors la
procédure supprime les derniers caractères de Ch à
partir de la position Pos.
Exemples : si Ch mémorise la valeur "123456" alors
Détruire(Ch, 2, 4) donne à Ch la valeur "16";
Détruire(Ch, 3, 10) donne à Ch la valeur "12" et
Détruire(Ch, 8, 2) laisse Ch inchangée, soit "123456".
Exercice 4
Écrire le sous-programme Insérer à trois paramètres :

Insérer(Flèche : chaîne de caractères; Var Cible :


chaîne de caractères; Pos : numérique) qui insère la
chaîne Flèche dans la chaîne Cible, après la position
Pos de Cible. Si Pos<0 ou Pos>Long(Cible) alors
aucune action n'est réalisée et Cible demeure inchangée.
Exemples :
si la variable St mémorise la valeur "123456" alors
Insérer("XX", St, 0) donne à St la valeur "XXI23456" ;
Insérer("XX", St, 3) donne à St la valeur "123XX456" et
Insérer("XX", St, 15) laisse St inchangée soit égale à
"123456".
Exercice 5
Écrire la fonction CompteCh(Ch : chaîne de
caractères) : numérique qui renvoie le
nombre de caractères numériques présents
dans Ch.
Exemples : CompteCh("BOND 007") renverra
3 et CompteCh("'LOUIS XVI") renverra 0.
Action P0
Procédure P1

Exercice 6
Procédure P2
Début
Sortir "Procédure P2"
FinProcédure
Procédure P3
Pour l'algorithme ci- Début

contre, donner :
Sortir "Procédure P3"
FinProcédure
Début
 Son arbre d'imbrication Sortir "Procédure P1"

d'écritures,
P2
P3
FinProcédure
 L'ensemble des Procédure P4
Procédure P5
programmes que les Début

sous-programmes P5 et
Sortir "Procédure P5"
FinProcédure

P4 peuvent appeler,
Procédure P6
Début

 Les possibilités
Sortir "Procédure P6"
FinProcédure

d'homonymies possibles
Début
Sortir "Procédure P4"

entre sous-programmes. P5
P6
FinProcédure
Début
Sortir "Procédure P0"
P1
FinAction

Vous aimerez peut-être aussi