Cours d’algorithmique by Ph. RIS est mis à disposition selon les termes de la licence Creative Commons Paternité – Pas d’Utilisation Commerciale – Pas de Modification 3.0 Unported. Le langage Pascal dispose d’un nombre limité d’instructions (writeln…) et de fonctions prédéfinies (cos…), mais il offre la possibilité de constuire de nouvelles instructions et de nouvelles fonctions.
Une procédure ou une fonction est un module d’un programme que celui-ci peut appeler aussi souvent que nécessaire. Parmi les avantages des modules, on peut citer :
- Gain de place.
- Lisibilité des programmes.
- Possibilité de réutilisation des modules dans d’autres programmes.
- Décomposition du problème en sous-problèmes, qui seront à leur tour décomposés, jusqu’à atteindre un niveau de difficulté élémentaire beaucoup plus facile à traiter… => structuration
Les liens entre programme principal et procédure sont les paramètres. En Pascal, il y a deux classes de paramètres :
- Paramètres d’entrée : données nécessaires à la procédure, mais dont la valeur ne doit pas être modifiée par elle,
- Paramètres d’entrée / sortie : variables attendues en donnée, mais dont la valeur doit être modifiée par la procédure.
Quant aux fonctions, elles attendent un certain nombre de paramètres en entrée, et renvoient une valeur d’un type simple (entier, réel, booléen, caractère, chaîne).
Sauf en ce qui concerne l’appel, une procédure ou une fonction n’est ni plus ni moins qu’un programme. Comme tout programme, elle travaille avec des variables dites locales), qui sont déclarées au début de la procédure, les paramètres étant également des variables et utilsés comme telles.
Règle 1 : Les variables du programme principal sont inconnues du module : C’est pourquoi les données dont il a besoin doivent lui être passées en paramètres.
Règle 2 : Les variables du module (hormis les paramètres d’entrée / sortie des procédures) sont inconnues du programme principal.)
Syntaxe : la définition d’un module consiste en un en-tête et un corps.
Procédure NomPcd (p11,…,pn1 : type1;… ;p1m,…,pnm: typem;
var p11,…,pp1 : typep;… ; var p11,…,pq1: typeq) ;
Function NomFct (p11,…,pn1 : type1;… ;p1m,…,pnm: typem: type_résultat;
Le corps d’un module est identique au corps d’un programme. La dernière construction d’une fonction doit être l’affectation d’une valeur à NomFct, considérée alors comme une variable de type type_résultat. Toute procédure doit être déclarée dans la section de déclaration d’un programme (avant le corps du programme lui-même). Une procédure type ressemble donc à :
PROCEDURE nom_de_la_procédure (paramètres) ;
CONST déclaration_des_constantes ;
TYPE déclaration_des_types_de_données ;
VAR déclaration_des_variables ;
BEGIN
corps_de_la_procédure ;
END ;
V.1. Procédures sans paramètres
V.1.a. Exemple
Program petits_services :
Uses crt ;
Procedure bip ;
begin
write(#7) ; { 7eme caractère de la table ASCII }
end ;
Procedure attend ;
var c : char ;
begin
write(‘Appuyer sur une touche pour continuer’) ;
c := Readkey ;
end ;
{ Maintenant, le corps du programme }
begin
bip ;
attend ;
bip ;
end.
V.1.a. Exercices
Reprendre le programme exemple1 du IV.1. Le modifier pour que le texte soit affiché par une procédure sans paramètres, qu’un bip soit émis tant que l’utilisateur n’entre pas une majuscule. Après chaque erreur, appeler dans ce programme la procédure clrscr (procédure standard du Turbo Pascal) qui efface l’écran.
V.2. Procédures avec paramètres passés par valeur
Les procédures sans paramètres sont pratiques mais ne permettent pas d’effectuer des traitements très compliqués. Aussi a-t-on recourt aux procédures permettant de prendre en entrée un certain nombre de paramètres.
La première catégorie de ces procédures prend en entrée la valeur de certaines variables du programme appelant ou encore des constantes. Considérons l’exemple suivant :
Program exemple_valeur ;
Uses crt ;
Procedure addition_entier (x, y : integer) ;
begin
writeln (‘Addition 1 : ‘,x+y) ;
x := y*2 ;
writeln (‘Addition 2 : ‘,x+y) ;
end ;
begin
{ début du programme principal }
x_principal, y_principal : integer ;
x_principal := 10 ;
y_principal := 20 ;
addition_entier (x_principal, y_principal ) ;
addition_entier (x_principal, y_principal ) ;
addition_entier (10, y_principal ) ;
addition_entier (10, 20 ) ;
addition_entier (5, 100 ) ;
y_principal := 20 + x_principal ;
x_principal := y_principal – 10 ;
end.
Dans cet exemple, la procédure addition_entier prend comme argument la valeur des variables x_principal et y_principal par exemple. Celle-ci ne change donc pas, même lorsque l’on effectue l’opération x := y*2 à l’intérieur de la procédure addition_entier.
Exercices :
1) Ecrire un programme qui demande en entrée deux nombres entiers, calculer leur addition, soustraction, multiplication et division (si le second nombre n’est pas nul !)
2) Récrire ce programme pour que toutes ces opérations soient effectuées par des procédures indépendantes prenant des paramètres par valeur.
3) La suite de Fibonacci est définie par :
Fn = Fn-1 + Fn-2
avec F0 = 1 et F1 = 2.
Écrire un programme qui demande en entrée quel terme de la suite on veut calculer, et qui appelle une procédure qui calcule ce nème terme et l’affiche. Ajouter un test qui vérifie qu’on ne demande pas le calcul au delà du 20ème terme.
5) Écrire un programme qui demande d’entrer une phrase et qui, dans une procédure affiche cette phrase comme elle a été tapée puis en majuscule (si car=’c’ alors UpCase(car)=’C’ et la fonction length(chaine) renvoie la longueur en caractères de chaine).
6) Écrire deux fonctions qui calculent le carré et le cube d’un réel. Ajouter une procédure prenant en entrée un entier n et un booléen b et affichant la somme des n premiers entiers au carré si b est vrai ou la somme des n premiers entiers au cube si b est faux.
V. 3. Procédures avec paramètres passés par adresse
Chaque variable est située à une adresse mémoire bien précise. Par exemple, on peut dire qu’une variable entière v est située à partir de l’adresse 102256 et qu’à cette adresse, on a stocké la valeur 150. Avec les passages de paramètres par valeur, nous aurions passé la valeur 150 pour v. Avec un passage par valeur, nous allons passer l’adresse de v soit 102256 dans cet exemple. L’intérêt du passage par valeur est que l’on peut modifier la valeur d’une ou plusieurs variables dans la procédure et que les variables du programme appelant soit modifiées en conséquence.
Par exemple, voici une procédure qui prend une chaîne de caractères en entrée, les met en majuscule et communique ce résultat au programme d’entrée.
Program par_valeur ;
Uses crt ;
var st_principal : string ;
Procedure en_majuscule (var st ; string) ;
var i : integer ;
begin
for i:=1 to length(st) do
st[i]:=UpCase(st[i]) ;
end ;
begin
writeln (‘Entrer une chaîne de caractères’) ;
readln (st_principal) ;
writeln (st_principal) ;
en_majuscule (st_principal) ;
writeln (st_principal) ;
end.
Exercices :
1) Écrire un programme qui, dans une procédure, échange la valeur de deux entiers (a devient b et b devient a).
2) Écrire un programme qui, dans une procédure ayant trois paramètres a1, a2, a3, qui sont des entiers, les échangent de façon à renvoyer au programme principal a1>a2>a3.
3) Ecrire un pragramme qui, dans une procédure ayant les trois paramètres suivants :
– une chaîne de caractères st,
– un caractère de réréfence c,
– un entier nb,
qui permet d’afficher dan le programme principal nb, qui est le nombre de fois où l’on trouve le caractère c, dans la chaîne st.
4) Écrire un programme qui, dans une procédure ayant les quatre paramètres suivants :
– une chaîne de caractères st,
– un entier nb,
– une chaîne de caractères gauche,
– une chaîne de caractères droite,
qui permet de renvoyer au programme principal les nb premiers caractères de la chaîne dans la variable gauche et le reste dans la variable droite.
NB : une chaîne est initialisée à nul par chaine= ». On pourra tester l’usage de la fonction copy(chaine, premier_caractère, nb).
V.4. Fonctions
Les fonctions peuvent se voir comme des procédures avec passage des paramètres par valeur mais ayant la particularité de renvoyer un unique résultat. Leur déclaration ressemble à :
FUNCTION fontion (paramètres) : type_sortie ;
CONST déclaration_des_constantes ;
TYPE déclaration_des_types_de_données ;
VAR déclaration_des_variables ;
BEGIN
corps_de_la_procédure ;
END ;
On les appelle par une commande du type :
a:=ma_fonction(p1, p2, p3) ; { a est du même type que ma_fonction }
Voici un exemple de fonction comptant le nombre de caractères c présents dans une chaîne :
Program compte_caractères ;
Uses crt ;
var n_principal : integer
Function comptage(st : string ; c : char ) : integer ;
var n,i : integer ;
begin
n:=0 ;
