NOTION DE FONCTION ET DE PROCEDURE

Introduction : les sous-programmes

Une application, surtout lorsqu’elle est longue, a toutes les chances de devoir procéder aux mêmes traitements, ou à des traitements similaires, à plusieurs endroits de son déroulement. Par exemple, la saisie d’une réponse par oui ou par non (et le contrôle qu’elle implique), peut être répétée dix fois à des moments différents dans la même application, pour dix questions différentes.

Il faut donc séparer ce traitement du corps du programme et regrouper les instructions qui le composent en un module séparé appelé sous-programme. Il ne restera alors plus qu'à appeler ce groupe d'instructions (qui n'existe donc désormais qu’en un exemplaire unique) à chaque fois qu’on en a besoin. Ainsi, la lisibilité est assurée ; le programme devient modulaire, et il suffit de faire une seule modification au bon endroit, pour que cette modification prenne effet dans la totalité de l’application.

Le corps du programme s’appelle alors le programme principal, et ces groupes d’instructions auxquels on a recours s’appellent des sous-programmes.

Lorsque le programme principal a besoin d’utiliser un sous-programme, il fait appel au sous-programme. Lors de l’appel d’un module, il y aura des échanges d’informations entre le module et le programme appelant. Cet échange est assuré par les paramètres.

Il existe deux types de sous-programmes : les procédures et les fonctions.

LES PROCEDURES

Définition

Une procédure est un sous-programme qui permet la résolution d’un problème précis et qui peut envoyer plusieurs résultats au programme principal appelé aussi programme appelant.

Les parties d’une procédure

La définition d’une procédure est constituée de trois parties :

a) L’en-tête : cette partie comporte le nom de la procédure suivi de l’ensemble des paramètres formels qui sont mis entre parenthèses. Chaque paramètre sera précédé par son mode de passage et suivi du type qui lui correspond.

b) La déclaration : cette partie sera réservée à la déclaration des objets locaux propres à la procédure.

c) Le corps : qui contient l’ensemble des instructions de développement de la procédure.

· Syntaxe de la définition d’une procédure :

Procédurenom_procédure (paramètre I : type : I,……………., paramètre N :type N) ;

/*Déclaration des variables et des constantes*/

Début

/*corps de la procédure*/

Fin nom_procédure

Exemple : Procédure qui demande la saisie d’un nom et d’un prénom à un utilisateur.

Procédure Saisie(x : chaine ; y : chaine) /*en-tête de la procédure */

var : x, y : chaine de caractères ; /*déclaration des variables propres de la procédure */

Début

Répéter

Ecrire (« Donner un nom ») ; Lire(x) ; /*corps de la procédure*/

Ecrire (« Donner un prénom ») ; Lire(y) ;

Jusqu’à (x= « ») et (y= « ») ;

FinSaisie

NB : Etant un sous-programme complet, une procédure peut contenir ses propres procédures et fonctions qui n’existent que lorsque la procédure principale est en cours.

Paramètres d’une procédure

Un paramètre est une variable d’entrée de la procédure. Les paramètres vont permettre l’appel de la procédure dans le programme principal, dans une procédure principale ou appelante.

Il existe deux types de paramètres : les paramètres formels (fictifs) et les paramètres réels (effectifs).

-Les paramètres formels (fictifs) sont des paramètres avec lesquels on définit le module (ils figurent dans l’en-tête de la déclaration de la procédure).

-Les paramètres réels (effectifs) sont ceux qui sont utilisés dans l’instruction d’appel du module.

Appel d’une procédure

Pour appeler une procédure, il suffit d’écrire son nom suivi des paramètres réels qui se substitueront aux paramètres formels lors de l’exécution de la procédure en respectant la syntaxe suivante :

Syntaxe :

Nom_de_la_procédure (paramètre effectif1, paramètre effectif2…..)

Dans le programme principal, il faudra déclarer la procédure comme on déclare n’importe quel objet.

Exemple : Appelons la procédure Saisie dans un programme principal :

Algorithme NomComplet

var A, B, C : Chaine de caractères ; /* déclaration des variables du programme principal */

Procédure Saisie ; /* déclaration de la procédure */

Début

Saisie (A, B) ; /* appel de la procédure*/

C← A &B ;

Ecrire (« Le nom complet est », C) ;

Fin

Remarque : Dans cet exemple, x et y sont des paramètres formels et A et B sont des paramètres réels.

Lors de l’appel d’une procédure, il faut respecter le nombre, l’ordre et le type des paramètres effectifs par rapport aux paramètres formels.

Modes de passage des paramètres

Il s’agit ici du mode de transfert des données entre le programme appelant et le programme appelé. On distingue deux modes de passage des paramètres :

a) Passage par valeur : Dans ce mode de passage, le programme appelant assure le transfert d’une valeur au programme appelé, même si ce paramètre subit une modification de sa valeur dans le programme appelé, cette modification ne doit pas être transmise au programme appelant, donc le transfert dans ce mode se fait de manière unidirectionnelle.

Appelant → Appelé

b) Passage par adresse ou par référence

Dans ce mode de passage, le programme appelant et le programme appelé font un échange de données. En effet, toute modification de la valeur d’un paramètre au sein du programme doit être communiquée au programme appelant, donc le transfert dans ce mode se fait dans les deux sens.

Appelant ⇆ Appelé

Dans l’en-tête de la procédure, il faut précéder les paramètres formels qui seront transmis par adresse par le mot clé var.

LES FONCTIONS

Définition

Une fonction est un sous-programme qui permet la résolution d’un problème précis et doit avoir un seul résultat de type simple (entier, réel, booléen, caractère ou chaine). Il s’agit d’un cas particulier des procédures.

Les parties d’une fonction

La définition d’une fonction est constituée de trois parties :

a) L’en-tête : cette partie comporte le nom de la fonction suivi de l’ensemble de la liste des paramètres formels qui sont mis entre parenthèses, et du type d’objet que la fonction va retourner. Chaque paramètre sera suivi du type qui lui correspond.

b) La déclaration : cette partie sera réservée à la déclaration des objets locaux propres à la fonction.

c)Le corps : qui contient l’ensemble des instructions de développement de la procédure.

· Syntaxe de la définition d’une fonction :

fonctionnom_de_la_fonction (paramètre I : type I ,….., paramètre N :type N) : Typevaleur_de_retour

/*Déclaration des variables et des constantes propres à la fonction */

Début

/*corps de la fonction*/

Retourner nom-d’une-variable retournée ;

Fin Fonction

· Exemple :Fonction qui effectue le produit de deux entiers

Fonction Produit (a : entier ; b : entier) : entier /* en-tête de la fonction */

var  P : entier ;/* déclaration des variables propres à la fonction*/

Début

P ← a*b ;

Retourner P ;

FinProduit

Appel d’une fonction

Pour appeler une fonction, il suffit d’écrire son nom suivi des paramètres effectifs qui se substitueront aux paramètres formels lors de l’exécution de la fonction en respectant la syntaxe suivante :

Syntaxe :

Nom_fonction (paramètre effectif1, paramètre effectif2…..)

Exemple : Appelons la fonction Produit dans un programme principal

Algorithme CalculProduit /* en-tête du programme principal */

var x, y, Prod : entiers ; /* déclaration des variables du programme principal */

fonction Produit ; /* déclaration de la fonction Produit */

Début

Ecrire (« veuillez entrer deux nombres entiers ») ;

Lire(x) ;

Lire(y) ;

Prod ← Produit (a, b) ; /* appel de

la fonction Produit*/

Ecrire (« Le produit des deux nombres x et y est », Prod) ;

Fin

REMARQUES : Les paramètres effectifs et les paramètres formels doivent correspondre de point de vue nombre, ordre et type.

· Une fonction possède un type qui est celui de son résultat.

• La fonction (ou la procédure) a un nom pour pouvoir être appelé.
• La fonction (ou la procédure) peut avoir un ou plusieurs paramètres contenant des valeurs ou des références sur des variables.
• Une fonction peut renvoyer une valeur au code qui l’a appelée. Ainsi, l’appel d’une fonction engendre le retour d’une variable qu’on peut affecter dans une autre variable ou bien la faire figurer dans une expression arithmétique ou logique, ou l’afficher directement.
• Tous les paramètres formels d’une fonction ont un mode de transfert par valeur

VARIABLES LOCALES ET VARIABLES GLOBALES

Les variables globales sont des variables définies dans le programme principal. Ces variables sont accessibles par tous les modules existants dans ce programme.

Une procédure, ou un module en général peut avoir ses propres variables locales qui seront réinitialisées à chaque appel. Ces variables n’existent que dans cette procédure ou cette fonction.

EXEMPLES DES PROGRAMMES UTILISANT LES PROCEDURES ET LES FONCTIONS

1-Exemple1 :

La mairie désire évaluer la taxe foncière à collecter dans un quartier de Yaoundé. Les lots de ce quartier sont des rectangles de longueur L et de largeur l. La valeur de la taxe foncière est de 1640 francs par m². Comme il y a des milliers de lots, on vous sollicite pour écrire un programme permettant de faire ce travail :

-Une procédure permettra de saisir (procédure Saisie) les dimensions de chaque lot.

-Une fonction permettra de calculer la surface (fonction CalculSurface) de chaque lot et d’envoyer le résultat au programme principal.

- Le programme principal doit récupérer toutes ces informations pour calculer le montant de la taxe foncière pour chaque individu, sommer les différents montants pour avoir un montant unique pour tout le quartier.

a) Procédure de saisie : cette procédure permet de saisir la longueur et la largeur d’un lot.

Procédure Saisie (var x: réel)

var x: réel ;

Début

Répéter

Ecrire « donner un réel positif » ;

Lire (x) ;

Jusqu’à (x= « »)

FinSaisie

b)

Fonction calculSurface : cette fonction calcule la surface de chaque lot.

Fonction CalculSurface (L :réel ; l :réel) : réel

var aire : réel ;

Début

Aire ← L*l ;

Retourner (Aire) ;

FinCalculSurface

c) Programme principal :

Algorithme taxeFoncière

const TAUX=1640 ;

var Montant, MontantTotal, surface, a, b : réels ; /* déclaration des variables du programme principal */

Procédure Saisie /* déclaration de la procédure */

Fonction CalculSurface /* déclaration de la fonction */

Début

MontantTotal ← 0 ; /* on initialise la somme à 0 */

Saisie(a,b) ; /* on appelle la procédure Saisie */

Surface ← CalculSurface (a,b) ; /* on appelle la fonction CalculSurface, le résultat est */

/*affecté dans une variable surface*/

Ecrire « Calcul de la taxe foncière » ;

Montant ← surface*TAUX ;

MontantTotal=MontantTotal + montant ;

Ecrire (« le montant total de la taxe est : », montantTotal) ;

Fin

Exemple2 :

Deux entiers m et n sont amis si la somme des diviseurs m (qu’on va appeler sdm) est égale à n et la somme des diviseurs de n(qu’on va appeler sdn) est égale à m. Pour vérifier si n et m sont amis, il suffit de comparer la somme des diviseurs de m à n et la somme des diviseurs de n à m. Deux cas se présentent :si sdm=n et sdn=m alors m et n son amis, sinon ils ne sont pas amis.

-Une procédure (saisie) permettra de saisir deux entiers m et n strictement positifs.

-une fonction (diviseur) permettra de calculer la somme des diviseurs de n et m.

-Le programme principal devra faire appel à la fonction et la procédure, comparer sdm à n, sdn à m, et afficher si m et n sont amis ou pas.

a) Procédure Saisie

Procédure Saisie (var x : entier)

var x : réel ;

Début

Répéter

Ecrire « Entrer un réel positif » ;

Lire(x) ;

Jusqu’à (x<= 0)

FinSaisie

b) Fonction Diviseurs

Fonction Diviseurs (x : entier) : entier ;

var x, Sdx : entier ;

Début

Sdx ← 1 ;

Pour i de 2 à (x DIV 2) Faire

Si (x MOD i = = 0) Alors

Sdx ← Sdx + i ;

FinSi

FinPour

FinDiviseurs

c) Programme principal

Algorithme_Ami

var m,n, Sdm, Sdn : entiers ;

Début

Saisie (m) ;

Saisie (n) ;

Sdm ← Diviseurs(m) ;

Sdn ← Diviseurs(n) ;

Si ((Sdm==n) et (Sdn==m) Alors

Ecrire « m et n sont amis » ;

Sinon

Ecrire « m et n ne sont pas amis »

FinSi

Fin

EXERCICES

CONTROLE SE CONNAISSANCES

1-Définir : sous-programme

2-Citer 02 types de sous-programmes.

3-Quelle est la différence fondamentale entre une fonction et une procédure ?

4-Quelle est la différence entre une variable locale et une variable globale ?

5-Quelle est la différence entre un paramètre fictif (formel) et un paramètre effectif (réel) ?

EXERCICE I : On donne l’algorithme suivant :

/*Programme principal */

1. Algorithme

2. Var carréNombre, i, S : entiers ;

3 Fonction calculCarré ;

3. Début

4.S ← 0 ;

5.Pour i allant de 1 à 5 Faire

6.carréNombre ←CalculCarré (i) ;

7.S ← S+ carréNombre ;

8.FinPour

9.Ecrire (« la somme des carrés des 5 premiers entiers est : », S) ;

10. Fin

/*Fonction*/

11. Fonction calculCarré (a: entier ;) : entier ;

12. var carré: entier ;

13. Début

14 carré ← a*a ;

15. Retourner (carré) ;

16. FincalculCarré

Questions :

1. Identifier une variable locale.

2. Identifier une variable globale.

3. Identifier paramètre fictif.

4. Identifier un paramètre effectif.

5. Quel est le mode transfert des paramètres pour cette fonction ?

EXERCICE II : On donne l’algorithme suivant :

/*Programme principal*/

1. Algorithme

2. tab : Tableau [1…5] de réels ;

3. var N, a, b, j : entiers ;

4. Procédure permuter ;

5. Debut

6. Pour i de N-1 à 1 Faire

7. Pour j allant de 1 à N-1 faire;

8. a← tab[j] ;

9. b ←tab[j+1] ;

10 Si a > b alors

11 Permuter (a, b) ;

12. FinSi

13. FinPour

14. FinPour

15. Fin

/*procédure*/

11. Procédure permuter (var A: entier, var B :entier)

12. var Aux: entier ;

13. Début

14.

15. Aux ← A ;

16. A  ← B ;

17. B  ←Aux ;

18.

19. Finpermuter

Questions :

1. Identifier une variable locale.

2. Identifier une variable globale.

3. Identifier un paramètre fictif

4. Identifier un paramètre effectif

5. Quel est le mode de passage des paramètres pour cette procédure ?

EXERCICE III : 

On se propose d'écrire un programme qui saisit un entier naturel n (100>n>20). Cet
entier n désigne le nombre d'étudiants d'une classe. On se propose de saisir pour
chaque étudiant, le nom, le prénom, la date de naissance, cinq notes d'examens et
leur moyenne pondérée par des coefficients. On veut déterminer et afficher la plus
grande moyenne permettant de faire passer au moins 75% des candidats, la liste
correspondante des candidats admis, la moyenne du plus jeune étudiant s'il est
admis et la moyenne du plus âgé s'il est admis aussi.
Questions
1) Définissez les structures de données adéquates à ce problème.
2) Spécifiez ce problème en le décomposant en modules.
3) Spécifiez chacun de ces modules.
4) En déduire l’algorithme de résolution relatif à chacun de ces modules ainsi que
celui du programme principal.

EXERCICES

CORRIGES

1-Sous-programme : C’est un bout de programme qu’un programme principal appelle au cours de son exécution pour effectuer des tâches répétitives.

NB : Le programme principal est le programme appelant et le sous-programme est le programme appelé.

2-Fonctions et Procédures.

3-Les fonctions retournent une valeur, les procédures pas.

4- Une variable globale s’applique dans le programme principal et tous les sous programmes alors qu’une variable locale s’applique seulement dans le sous-programme dans lequel elle est définie.

NB : Une variable globale est définie dans le programme principal.

5-Un paramètre formel est utilisé pour définir un sous-programme alors qu’un paramètre réel et utilisé lors de l’appel du sous-programme.

EXERCICE I :

1. Variable locale : carré

2. Variable globale :carréNombre

3. Paramètre fictif : a

4. Paramètre effectif : i

5. Par valeur.

NB : Les fonctions utilisent en général un mode de transfert par valeur.

Quel est le mode de passage des paramètres pour cette procédure ?

EXERCICE II :

1. Variable locale : Aux

2. Variable globale : a

3. Paramètre fictif : A

4. Paramètre effectif : a 

5. Par variable.