Les sous programmes
1. Généralités.
2. Avantages des sous programmes.
3. Structure d'un programme . 4. Procédure et fonction .
5. Déclaration de procédure simple.
6.Procédure simple avec des variables locales.
7.Procédure paramétrée.
8. Communication entre procédures.
9. Mode de passage de Paramètres.
10. Les fonctions.
****************************************************
1°) GENERALITES.
Lors de la conception d’un programme résolvant un problème général, il est nécessaire de décomposer le problème en différent sous-problèmes moins complexe à résoudre : Démarche ascendante.
Ces différents sous-problèmes peuvent être résolus grâce à des sous-programmes particuliers : Procédures et fonctions.
Exemple : Écrire un programme qui affiche en ordre croissant les notes d'une promotion suivies de la note la plus faible, de la note la plus élevée et de la moyenne
Revient à résoudre les problèmes suivants :
- Remplir un tableau de réels avec des notes saisies par l'utilisateur - Trouver le plus petit réel d'un tableau
- Trouver le plus grand réel d'un tableau - Calculer la moyenne d'un tableau de réels.
Donc écrire un programme qui résout un problème revient toujours à écrire des sous-programmes qui résolvent des sous parties du problème initial
Un sous-programme est obligatoirement caractérisé par un nom (un identifiant) unique
Lorsqu'un sous programme a été explicité (on a donné l'algorithme), son nom devient une nouvelle instruction, qui peut être utilisé dans d'autres (sous-)programmes
Le (sous-)programme qui utilise un sous-programme est appelé (sous-)programme appelant.
2°) Avantages des sous programmes.
● Les sous programmes permettent de ne pas répéter plusieurs fois une même séquence d’instructions au sein du programme.
● La mise au point du programme est plus rapide en utilisant des sous programmes. En effet, elle peut être réalisée en dehors du contexte du programme.
● Un sous programmes peut être intégré à un autre programme, ou elle pourra être rangée dans une bibliothèque d’outils ou il pourra être utilisé par n’importe quel programme.
Exemple de problème
Écrire un algorithme qui calcule et affiche la moyenne des valeurs absolues de trois nombres A,B,C, sachant qu'on n'a pas la fonction ABS.
Algorithme MoyValAbsolu ; Déclaration
A,B,C,A1,B1,C1 : entier ; moy : réel ;
Début
· valeur absolue a été effectué 3 fois de la même
· manière pour A, pour B et pour C.
· il serait préférable de prévoir un module ou sous
· programme consacré au calcul ou traitement de la
· valeur absolue isolée.
· Aussi on peut écrire un sous programme pour le Fin
Dans cet algorithme le calcul de la valeur absolue a été effectué 3 fois de la même manière è Il est préférable d’écrire un sous programme consacré au calcul de la valeur absolue.
è On peut aussi écrire un sous programme pour le calcul de la moyenne de 3 nombres.
Algorithme MoyValAbsoluVers2 déclaration
A,B,C:entier ; M : réel
fonction Absolu(X :entier) :entier Début
Si X < 0 alors Absolu← -X Sinon Absolu ← X Fin si Fin
fonction Moyenne(X :entier ; Y :entier ; Z :entier):réel ; Début
Moyenne ← (X+Y+Z)/3 Fin
Début Lire(A,B,C)
M ← Moyenne(Absolu(A),Absolu(B),Absolu(C)) Écrire(M)
Fin .
3°)Structure d'un programme :
Un programme doit suivre la structure suivante : Programme nom du programme
Définition des constantes Définition des types
Déclaration des variables globales Définition des sous-programmes début
instructions du programme principal
fin
4°) Procédure et fonction :
On perçoit un programme comme un programme principal et un ensemble de procédure/fonctions. Ce découpage est à la base de la programmation structurée.
Procédures : Une procédure est un sous-programme exécutant une suite d'actions. Elle ne retourne aucun résultat, elle peut être perçue comme une boîte noire exécutant une tâche donnée.
Deux types de procédures : - La procédure simple - La procédure paramétrée
Fonctions : Une fonction est un sous-programe qui retourne obligatoirement une valeur.
4 .1 Exemples de procédures et fonctions standards : Procédures standard : readln ;
Fonctions standard : ord( i) ;
4.2 Sous programmes défini par l’utilisateur : 4.2.1 Déclaration de procédure simple :
Ce type de sous-programme exécute une tâche précise. Cette tâche est indépendante des autres sous programmes et donc ne permet pas de partager des informations.
Exemple :
Procédure afficher ( );
Début
Ecrire(‘ mot de passe incorrect, veuillez entrer un nouveau mot de passe’) ; Fin
Définition d'une procédure simple : procédure nom_procédure ( ) ; Déclaration
//variables locales Début
// Actions Fin
Les variables locales sont utilisées uniquement dans la procédure.
La procédure simple ne doit utiliser que les variables locales.
Appel d'une procédure simple
Pour exécuter le contenu d'une procédure simple, on écrit le nom de la procédure comme si elle était une action connue.
Une procédure peut-être appelée à partir d'un programme ou d'un autre sous- programme.
Exemple
Algorithme mot-passe ; Déclaration
mot : entier ;
Procédure afficher ( );
Début
Ecrire(‘ mot de passe incorrect’) ; Fin
début lire ( mot) ;
tant que mot < > ‘27122008’ faire afficher ( ) ;
lire (mot) ; FinTQ Fin
Principe de fonctionnement :
Prg appelant prg appelé
Afficher( ) Début -- -- -- Fin.
(mot-passe ) --
--
Afficher( ) ; --
--
4.2.2 Procédure simple avec des variables locales : Exemple :
Écrire une procédure qui "saute trois lignes" sur l'écran
Version 1
Procedure Saute3Lignes;
Begin WriteLn;
WriteLn;
WriteLn End;
Pas d’évolutivité Sans paramètres
Version 2
Procedure Saute3Lignes;
Var i : Integer;
Begin
For i:= 1 To 3 Do Begin
WriteLn End End
;
Plus évolutif car Mieux "Paramétré"
Version 2bis
Procedure Saute3Lignes;
Const N = 3;
Var i : Integer;
Begin
For i:= 1 To N Do WriteLn End;
4.2.3 Procédure paramétrée :
Déclaration de la procédure paramétrée
ProcédureNomProcédure (Paramètres Formels avec leur Types) déclaration
Déclaration des variables locales Débuts
[…]
Instructions
[…]
Fin
Outils locaux et globaux Définitions :
- La portée d’une variable est l’ensemble des sous-programmes où cette variable est connue (les instructions de ces sous-programmes peuvent utiliser cette variable)
- Une variable définie au niveau du programme principal (celui qui résouds le problème initial, le problème de plus haut niveau) est appelée variable globale
Sa portée est totale : tout sous-programme du programme principal peut utiliser cette variable - Une variable définie au sein d’un sous programme est appelée variable locale
La portée d’une variable locale est uniquement le sous-programme qui la déclare
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
Les déclarations locales. Peuvent être : è des déclarations de constantes (blocs const) è de variables (blocs var)
è ou d'autres procédures.
CONSEIL :
Il faut éviter au maximum les variables globales (sauf les constantes) : trop d’espace mémoire
Exemple :
X de A Y de A Y de B X d'Essai Y d'essai
I : erreur , inaccessible
Les paramètres formels/effectifs :
•les paramètres formels sont des identificateurs de variables fictives utilisées pour introduire des données dans la procédure ou sortir des résultats dans la procédure
•Un paramètre effectif est une variable ou constante (numérique ou définie par le programmeur) Le paramètre formel et le paramètre effectif sont associés lors de l’appel du sous-programme Le paramètre formel et effectif doivent donc être de même type.
4.2.4 Communication entre procédures :
On entend par communication, l’échange d’informations, la communication entre procédure se fait au moyen de variables globales ou locales :
a) Communications par variables globales : Exemple :
Program afficher ; Var
N : integer ;
Procedure SauteLignes ( );
Var i : Integer;
Begin
For i:= 1 To n Do Begin
WriteLn;
End End;
Begin
Writeln(‘ entrez le nombre de lignes à sauter’) ; Readln( n) ;
Sautlignes() ; Fin.
C’est une communication implicite et bilatérale car les variables globales peuvent être modifiées par la procédure et le programme principal, c’est la seule alternative pour les procédures sans paramètres.
b) Communications par paramètres :
Le besoin de paramétrer une procédure se fait senti quand cette même procédure peut être exécutée avec valeurs différentes :
Notation : procedure nom-proc ( paramètres formels : type ) ; Exemple : Procedure SauteLignes ( x : integer );
Les paramètres formels : la déclaration des paramètres formels à l’entête de procédure décrit les données attendus par la procédure pour s’exécuter, ce sont des variables locales à la procédures.
Les paramètres effectifs : ce sont les données communiquées à la procédure au moment de son appel, les paramètres effectifs sont substitués par les paramètres formels ; et doivent correspondre en nombre , en type et en ordre aux paramètres formels.
Exemple :
Procedure ligne ( c ;char , i : integer) ; Var j: integer;
Begin
For j := 1 to I do Write ( c);
End;
Ligne ( * , 2 ) affichera : **.
Ligne ( Z, X) ou x = 5 affichera : ZZZZZ .
A l’appel d’une procédure les actions suivantes sont réalisées :
- faire correspondre à chaque paramètre formel son paramètre effectif.
- Exécuter les actions de la procédure appelée.
- Revenir à la procédure appelante et reprendre l’exécution des instructions restantes.
4.2.5 Mode de passage de Paramètres En Pascal, il y en 2 :
- passage par valeur
- passage par référence ou adresse.
a) Passage par valeur :
-Les instructions du sous-programme ne peuvent pas modifier le paramètre effectif En fait c’est la valeur du paramètre effectif qui est copiée dans le paramètre formel -C’est le seul passage de paramètre qui admet l’utilisation d’une constante
-Ce type de transmission ne permet pas de transmettre des résultats à un autre module
(procédure ou fonction) ou au programme principal par l’intermédiaire du paramètre effectif, étant donné que le contenu de celui-ci n’est pas modifié au retour de la procédure.
-La déclaration d’un paramètre par valeur s’effectue selon le format suivant : PROCEDURE NomProcedure(parametre : TypeParametre);
Exemple : Notons que, dans la procédure SautLigne de l’exemple précédent le paramètre nblignes est déclaré par valeur.
b)Passage par variable ou par adresse : Lors de l’appel :
- Le paramètre effectif doit être une variable de type compatible.
- Son adresse sera envoyée à la procédure
- La procédure travaillera donc directement sur sa valeur.
- Donc toute modification sera définitive - La procédure peut le consulter et le modifier
La déclaration d’un paramètre par variable s’effectue selon le format suivant : PROCEDURE NomProcedure(VAR parametre : TypeParametre);
On notera le recours au mot clé VAR pour introduire le ou les paramètres que l’on veut transmettre par variable.
Exemple :
PROGRAM Progperm;
VAR
val1, val2 : REAL;
PROCEDURE Permuter(X, Y : REAL); {En-tete de la procedure}
VAR
tampon : REAL;
BEGIN {Debut de la procedure}
tampon := X;
X := Y;
Y := tampon;
END; {Fin de la procedure}
BEGIN {Debut du programme principal}
Val1 := 100 ; val2 := 400 ;
Permuter(val1, val2); résultat : X= 100 , Y= 400 WRITELN('X = ', val1 : 4, 'Y = ', val2 : 4);
END. {Fin du programme principal}
Les paramètres X et Y doivent être transmis par variable, ce qui aura pour effet de rendre disponibles, à la sortie de la procédure, les nouvelles valeurs effectives de ces paramètres.
PROGRAM Progpermut;
VAR val1, val2 : REAL;
PROCEDURE Permuter(VAR X, Y : REAL); {En-tete de la procedure}
VAR
tampon : REAL;
BEGIN {Debut de la procedure}
tampon := X;
X := Y; a résultat : X= 400 , Y= 100 Y := tampon;
END; {Fin de la procedure}
BEGIN {Debut du programme principal}
val1 := 100 ; val2 := 400;
Permuter(val1, val2);
WRITELN('VAL1 = ', val1 : 4, 'VAL2 = ', val2 : 4);
END. {Fin du programme principal}
Mentionnons enfin qu’une procédure peut elle-même appeler d’autres procédures : c’est ce qu’on appelle l’imbrication de procédures.
Program essai ;
Procedure Incrementer (X : integer ; Var Y : integer) ;
Var K : integer ;
{1}
Begin
K := 2 ; X := X + K ; Y := Y + K ;
writeln ('X=',X,' & Y=',Y, '&K=', K); {2}
End ;
Var A, B, K : integer ;
Begin A := 3 ; B := 2 ; K := 3 ; Incrementer (A, B) ;
writeln ('A=',A,' & B=',B, ' & K=', K) End.
4.2.3. Les fonctions :
- Une fonction est un sous-programe qui retourne obligatoirement une valeur.
- Lors d'un appel, une fonction est considérée comme une expression du type de la valeur retournée (exemple : si la fonction retourne un entier, on considère la fonction comme une expression entière).
a)Généralités
On distingue deux catégories de fonctions : les fonctions standards et les fonctions non standards.
- Par fonction standard, on entend toute fonction connue du langage. C’est le cas, entre autres, des fonctions ABS, TRUNC, ROUND, SQR, SQRT, PRED, SUCC que nous avons déjà vues.
- Par fonction non standard, on entend toute fonction non connue du langage et qui, par conséquent, nécessite une définition préalable à son utilisation.
b)Les fonctions paramétrées
Une fonction avec paramètres a pour format :
fonction nom de la fonction (paramètre(s) de la fonction) : type de la valeur retournée Déclaration variable locale 1 : type 1; . . .
début
instructions de la fonction fin
fonction abs (unEntier : Entier) : Entier début
si unEntier >0 alors abs← unEntier sinon
abs← -unEntier finsi
fin
En pascal : FUNCTION NomFonction(ListeDeParametres) : TypeFonction;
où ListeDeParametres désigne la liste (non vide) déclarée des paramètres formels de la fonction, et TypeFonction le type de la fonction, c’est-à-dire celui du résultat calculé ou généré par cette fonction.
Exemple :
Program addition ; Var X, Y,Moy :real ;
FUNCTION Somme(nombre1, nombre2 : REAL); Real; {En-tete de la fonction}
BEGIN {Debut de la fonction}
Somme := nombre1 + nombre2;
END;{Fin de la fonction}
Begin
Readln ( X ,Y ) ;
Moy := somme ( X, Y) / 2 ; Writeln( ‘ la moyenne : ‘ ,moy) ; End.
- le passage de paramètre est uniquement par valeur
