5. Les fonctions, les procédures.
5.1 A quoi ça sert ?!
Les fonctions (et les procédures) permettent de condenser une suite
d'instructions en un seul mot (ou groupe de mots). Les fonctions offrent
de nombreux avantages au programmeur:
Au lieu de faire des milliers de lignes, un programme (même complexe)
peut être réduit à quelques lignes. Cela offre beaucoup
plus de clarté au programme.
Le programmeur n'a pas à réecrire plusieurs fois les bouts
de code qu'il utillise fréquemment. Cela fait gagner beaucoup de
temps
Le programme est divisé en petites parties: il est plus facile d'isoler
les erreurs...
Par exemple, si un programme doit dessiner trois rectangles ABCD, EFGH
et IJKL à l'écran. Un programme effectuant cette tâche
sans utiliser de procedures aurait le schéma suivant (noter que
le texte ci-dessous n'est pas du pascal, mais un subsitu de langague destiné
à simplifier l'example):
Debut
Défini la position des point A,B,C,D,E,F,G,H,I,J,K,L
Trace le segment [AB]
Trace le segment [AD]
Trace le segment [CB]
Trace le segment [CD]
Trace le segment [EF]
Trace le segment [EH]
...
Trace le segment [LK]
Trace le segment [LJ]
Fin
On se rend compte que l'écriture d'un tel programme serait fastidieuse,
imaginez le listing si on avait une dizaine de rectangles à dessiner!
Faire appel à des procédures simplifie beaucoup la tâche:
Début
Déclare la procédure "Trace le Rectangle (pointHG,pointHD,pointBD,pointBG)"
Trace le segment [pointHG pointHD]
Trace le segment [pointBG pointBD]
Trace le segment [pointHG pointBG]
Trace le segment [pointHD pointBG]
Fin de déclaration procédure
Défini la position des point A,B,C,D,E,F,G,H,I,J,K,L
Trace le Rectangle (A,B,C,D)
Trace le Rectangle (E,F,G,H)
Trace le Rectangle (I,J,K,L)
Fin
Ces deux programmes font strictement le même chose, mais le deuxième
est plus clair. Si on a un nouveau rectangle à dessiner, on n'a
pas besoin de réecrire les suite des 4 instructon "trace le segment",
mais simplement une instruction "trace le rectangle". On évite de
même bien des erreurs: si tous les rectangles sont mals dessinés,
il suffit juste le corriger la procedure "trace le rectangle" et ça
roule. La procedure "tracer un rectangle" sera utilisable à volonté
dans le programme.
On voit tout de suite l'utilité des procédure/fonctions
(enfin, si mon exemple est assez clair!). S'il existe de nombreuses fonctions
intégrées au Pascal objet de Delphi (la fonction "tracer
le rectangle" est présente!), il est tout à fait possible
d'écrire ses propres fonctions et procédures.
5.2 Faire appel aux procédures
Pour faire appel aux procédures préexistantes, la syntaxe
est simple:
nom_de_la_procedure(argument_1, argument_2,... , argument_n);
Nous avons déjà vus des arguments dans l'example précèdant:
la procedure "trace le rectangle" possédant 4 arguments qui étaient
chacuns des points.
Chaque procédure possédure un nombre précis d'argument
(il peut très bien n'y en avoir aucun) et chaque argument possède
un type précis. L'aide est bien utile quand on ne se rappelle plus
des arguments que nécessite une fonction!
La seule différence entre les procédures et les fonctions
est que le premier type ne renvoie aucune valeur, alors que le second type
renvoie toujours une valeur.On peut comparer les fonctions pascal aux fonctions
mathématiques: par exemple, la fonction sinus possède un
argument réel (l'angle) et renvoie une valeur réelle (la
valeur de l'angle). On écrit par exemple: x=sin(a). Et bien en pascal,
c'est le même chose: on a la fonction sinus est utilisée ainsi:
var
A:double;
angle:double;
begin
angle:=30;
A:= sin(angle);
end;
Après cela, la variable A contient la valeur réelle 0,5.
Il faut toujours respecter le type des arguments (valable aussi pour les
procédures): on ne peut pas calculer le sinus d'une chaîne
de caractères! La variable qui accepte la valeur de retour de la
fonction doit aussi être d'un type adapté.
5.3 Déclarer ses propres fonctions et procédures
Avant de se lancer dans l'écriture d'un fonction (ou d'un procédure),
il faut bien déterminer son rçole et savoir ce qu'on va lui
envoyer (par les paramètres).
Voici la déclarations d'une procédure simple:
procedure AfficheNombre(nombre : Integer);
begin
application.showmessage(inttostr(nombre));
end;
La procédure ci-dessus ne fait qu'afficher un message contenant
le nombre en paramètre.
Pour déclarer une procédure, c'est donc simple:
procedure nom_de_la_procedure(argument1:Type, argumenté:Type,
... , argumentN:Type);
begin
{Corps de la procédure}
end;
Le principe est le même pour les fonctions, il simplement préciser
en plus le type de la valeur de retour:
function nom_de_la_fonction(argument1:Type, argument2:Type,
..., argumentN:Type):Type;
begin
{Corps de la fonction}
end;
Le nombre d'argument peut être nul. Les arguments peuvent être
de type différent. Le corps de la procedure/fonction peut contenir
toute sorte d'instructions, faire appel à des procedures ou fonctions.
Une fonction peut même s'appeler elle-même! (voir Récurrence);
Le Guide du Programmeur Débutant
sous Delphi.
Ce document à été mis à jour
le 28/05/98. |
|
Ecrit par redmatth.
|