cours ASD1 pour les première année informtqiue (ch6: les sous programmes)

1. 1
1
Algorithmique & structures
de données I
1ère IAG
Responsable : Dr. Fadoua Bouafif
Dr.fadoua Bouafif
2
Chapitre 6
Les Sous-programmes
Dr.fadoua Bouafif
Objectifs du chapitre
 Savoir la programmation modulaire
 Apprendre la manipulation des modules (sous-
programmes) en algorithme et en C
 Connaitre les types de paramètres et leurs passages dans
les sous-programmes
3
Dr.fadoua Bouafif
Plan du chapitre
1. Introduction
2. Les types de sous-programmes
3. Les prototypes et les sous-programmes
4. Les variables globales et les variables locales
5. Les paramètres et le passage des paramètres
6. Conclusion
4
Dr.fadoua Bouafif
1 2
3 4

2. 2
Introduction
 La manipulation et la résolution d'un problème complexe nécessite l’usage des sous programmes
qui seront par la suite appelés par l'algorithme principal (programme principal en C).
 Les sous programmes permettent de :
 Réduire la complexité des programmes
 Décomposer le programme en des sous modules cohérents
 Le paramétrage et la lisibilité des programmes.
 Réutiliser les sous programmes sans avoir à les redéclarer.
 Faciliter les opérations de maintenance et/ou de modification des programmes
 gain de temps (CPU) et gain de l'espace mémoire (MC).
 Un sous programme utilise des paramètres avec lesquels il sera appelé dans le programme
principal.
5
Dr.fadoua Bouafif
Introuduction (suite)
6
Déroulement d’un programme
Dr.fadoua Bouafif
Les types de sous-programmes
 Il existe deux types de sous programmes :
 Les procédures: représentent une action, qui peut être
complexe à entreprendre, et peuvent aussi calculer une ou
plusieurs valeurs
 Les fonctions: calculent et retournent une valeur et une
seule.
7
Dr.fadoua Bouafif
8
Les Procedures
Dr.fadoua Bouafif
5 6
7 8

3. 3
Définition
 Une procédure est un sous programme qui peut être appelé soit:
 Par l’algorithme (programme) principal
 Par un autre sous programme.
 Une procédure peut être appelée comme une instruction dans un programme par
l'intermédiaire de son nom suivi de sa liste de paramètres effectifs (s'ils existent).
9
Dr.fadoua Bouafif
Déclaration
10
En Algorithmique En C
procédure nom_sp (liste paramètres formels+types)
var : // déclaration des variables locales (internes)
début
...... // Liste des instructions ;
......
fin
**********************************************
Algorithme nom_algorithme
var : ....... // déclaration des variables
début
....
// appel de la procedure
nom_sp (liste_paramètres_réels)
....
Fin
void nom_sp (liste paramètres formels+types)
{
// Déclaration des variables locales (internes);
// Liste des instructions ;
.....
}
*******************************************
void main()
{
// déclaration des variables
……..
// appel de la procedure
nom_sp (liste_paramètres_réels) ;
…….
}
Dr.fadoua Bouafif
Exemple
11
En Algorithmique En C
procédure somme( x:entire, y:entier )
var : som: entier
début
Som x+y
écrire (“la somme de”,x, y, “= “ ,som)
Fin
********************************
Algorithme test
var : a,b:entier
Début
ecrire(“donner deux valeurs”)
lire(a,b)
somme(a,b)
Fin
#include <stdio.h>
void somme ( int x, int y)
{
int som;
som=x+y;
printf (“ la somme de %d et %d =%dn”, x ,y, som) ;
}
*****************************
void main ( )
{
int a,b;
printf(“donner deux valeurs”);
scanf(“%d%d”,&a, &b);
somme(a,b);
}
Dr.fadoua Bouafif
Remarques
 Une procédure est appelée dans une action spécifiant son nom et ses paramètres effectifs en
respectant leurs modes de passage respectifs.
 En C, le type prédéfini void indique l'absence d'une valeur de retour. Il est aussi un type
particulier qui indique un ensemble vide de valeurs.
 Dans la déclaration d'un sous programme qui ne possède aucun argument (paramètre), liste
vide, le type void ou des parenthèses vides est(sont) employé(s).
12
Dr.fadoua Bouafif
9 10
11 12

4. 4
Activité
 Ecrire un algorithme (programme C) qui permet de définir et d’appeler une procédure
Minimum qui renvoie le plus petit de deux nombres différents
13
Dr.fadoua Bouafif
14
Les Fonctions
Dr.fadoua Bouafif
Définition
 Une fonction, contrairement à la procédure, doit avoir un type, c.à.d.
qu'elle doit remettre une valeur en sortie.
 Une fonction est caractérisée par un nom et permet de renvoyer une
valeur (résultat) au programme qui va l'appeler.
15
Dr.fadoua Bouafif
Déclaration
16
En Algorithmique En C
fonction nom_sp (paramètres formels+types) : type de retour
var : // déclaration des variables locales (internes)
début
//Liste des instructions
......
retourne (variable_résultat)
Fin
*************************************************
Algorithme nom_algorithme
var : nom_variable : type de retour
.......
début
// appel de la fonction
nom_variable  nom_sp (paramètres_réels)
....
Fin
type de retour nom_sp (paramètres formels+types)
{
//Déclaration des variables locales (internes);
//Liste des instructions ;
.....
return (variable_résultat);
}
***************************************************
void main()
{
Type de retour variable_resultat ;
// appel de la fonction
variable_ resultat = nom_sp (paramètres_réels) ;
……
}
Dr.fadoua Bouafif
13 14
15 16

5. 5
Exemple
17
En Algorithmique En C
fonction carre (x : entier) : entier
var : c : entier
début
c  x * x
retourne (c)
Fin
*****************************
Algorithme test
var : n, p : entier
début
écrire ("Saisir une valeur :")
lire (n)
p  carre(n)
Écrire ("Le carre de", n, "est ", p)
Fin
#include <stdio.h>
int carre (int x)
{
int c ;
c = x * x ;
return(c) ;
}
************************************
void main()
{
int n, p ;
printf("Saisir une valeur :") ;
scanf("%d", &n) ;
p = carre(n) ;
printf("Le carre de %d est %d", n, p) ;
}
Dr.fadoua Bouafif
Remarques
 Puisque la fonction renvoie un résultat unique, alors lors de son appel le
résultat retourné est affecté à une variable déclarée dans l'algorithme
(programme principal) correspondant et qui a le même type de retour.
 En C, si la fonction contient plusieurs paramètres de même type, ils doivent
être déclarés séparément.
18
Dr.fadoua Bouafif
Activité
 Ecrire un algorithme (programme C) qui permet de définir et d’appeler une
fonction Minimum qui renvoie le plus petit de deux nombres différents
19
Dr.fadoua Bouafif
20
Les prototypes
&
les sous-programmes
Dr.fadoua Bouafif
17 18
19 20

6. 6
Definitions
 Un sous programme peut être déclaré avant ou après l'algorithme (programme) principal.
 Dans le cas où le sous programme est définit après l’algorithme principal, le prototype du
sous programme doit être déclaré avant l'algorithme (programme) principal.
 Le prototype d’un sous programme contient uniquement la liste des paramètres formels ainsi
que leurs types.
 En C, le prototype d’une fonction peut être définit de deux manières :
Type_resultat nom_sp (TypePar1, TypePar2, ...) ; ou bien
Type_resultat nom_sp (type1 parm1, type2 parm2, . . ., typen parmn) ;
21
Prototype en Algorithmique Prototype en C
procédure nom_sp (p1 :type1, p2 : type2, ...., pn :typen)
fonction nom_sp1 (p1 :type1, p2 : type2, ...., pn :typen) : typeretour
void nom_sp (type1 p1, ...., typen pn) ;
Type_resultat nom_sp1 (type1 p1, ...., typen pn) ;
Dr.fadoua Bouafif
Syntaxe en Algorithme
22
En Algorithmique- sous programme après l’algorithme principal
// déclaration des prototypes
procédure nom_sp (p1: type1, p2: type2, ...., pn: typen)
fonction nom_sp1 (p1: type1, ...., pn: typen) : typeretour
***************************************************************************
// algorithme principal
Algorithme Nom_algorithme
var : nom_variable : typeretour
.......
début
....
nom_sp (p1, p2, ...., pn)
....
nom_variable  nom_sp1 (p1, p2, ...., pn)
....
fin
//définition sous-programme
procédure nom_sp (p1: type1, p2: type2, ...., pn: typen)
var : // déclaration des variables locales (internes)
début
......
Fin
*********************************************************
fonction nom_sp1 (p1: type, p2: type, ...., pn: type) : typeretour
// déclaration des variables locales (internes)
var : variable_résultat : typeretour
début
......
......
retourne (variable_résultat)
fin
Dr.fadoua Bouafif
Syntaxe en C
23
En C- sous programme après le programme principal
#include <stdio.h>
// declaration des prototypes
void nom_sp (type1 p1, ...., typen pn) ;
Type_resultat nom_sp1 (type p1, ...., type pn) ;
//programme principal
**************************************************
void main()
{
Type_resultat var_resultat ;
....
nom_sp (p1, ...., pn) ;
....
var_resultat = nom_sp1 (p1, ...., pn) ;
....
}
//définition sous-programme
void nom_sp (type1 p1, ...., typen pn) ;
{
//Déclaration des variables ;
...
…
}
***********************************************
Type_resultat nom_sp1 (type p1, ...., type pn)
{
//Déclaration des variables ;
Type_resultat var_resultat ;
Liste des instructions ;
.....
return (var_resultat) ;
}
Dr.fadoua Bouafif
Les variables globales & les variables locales
24
 Une variable est dite globale si elle est déclarée dans l’algorithme (programme) principal, hors de
sous programme, mais qui peut être utilisée par ces sous programmes.
 Une variable globale a une durée de vie égale à celle de l’algorithme (programme) en entier.
 Une variable est dite locale si elle est déclarée à l'intérieur du sous programme. Elle démarre son
existence au moment de l'appel du sous programme, et est détruite lors de l'achèvement du sous
programme.
 Une variable locale a une durée de vie égale à celle du sous programme où elle est définie.
 Une variable locale définie dans un sous programme est visible partout à l'intérieur du sous
programme et invisible à l'extérieur.
 Les variables globaux et standards sont visibles en tout point de l’algorithme (programme).
Dr.fadoua Bouafif
21 22
23 24

7. 7
Activité
Écrire un algorithme (programme C) qui permet de saisir deux entiers N1 et N2 strictement
positifs et de calculer et d’afficher la somme si N1>N2 et le produit si N2>=N1.
On utilisera
 Un sous-programme « somme() » qui retourne la somme de deux entiers.
 Un sous-programme « produit() » qui retourne le produit de deux entiers.
 Un sous-programme « Affiche() » qui affiche le résultat de l’opération
25
Dr.fadoua Bouafif
Les paramètres & le passage des paramètres
 Les paramètres:
 formels sont déclarés au sein des sous-programmes
 effectifs ou réels se trouvent dans l'algorithme principal
 Passage des paramètres:
 Par valeur
 Par adresse
26
Dr.fadoua Bouafif
Les paramètres
 Les paramètres formels et les paramètres effectifs doivent correspondre en nombre, type et
ordre respectivement.
 Il existe trois types de paramètres formels :
 paramètres données (entrés): ils ne changent pas de valeur dans le sous-programme. Leurs
valeurs sont plutôt utilisées.
 paramètres résultats (sorties): ils n'ont pas de signification qu'après l'exécution du sous-
programme.
 paramètres données/résultats (E/S): ils ont une valeur avant l'exécution du sous-programme
et qui peut changer après exécution.
27
Dr.fadoua Bouafif
Passage des paramètres par valeur: définition
 C'est le mode de passage par défaut des paramètres dans un sous-programme.
 Dans ce type de passage, le sous programme copie la valeur à transférer au sein du sous
programme lui même; Ce dernier utilise alors cette copie sans modifier la valeur initiale.
 Le paramètre formel représente une variable locale au sous-programme et tout changement de
ce paramètre n'a aucun effet sur le paramètre effectif (réel).
 La modification de ce paramètre reste locale au sous-programme.
 A l'appel, les valeurs des paramètres effectifs sont récupérées dans les paramètres formels sur
lesquels le traitement va s’effectuer. Ainsi, un paramètre effectif transmis par valeur ne peut
pas être modifié.
28
Dr.fadoua Bouafif
25 26
27 28

8. 8
En Algorithmique En C
procédure nom_sp (p1: type1, p2: type2, ...., pn: typen)
var : // déclaration des variables locales (internes)
début
......
Fin
******************************************************
fonction nom_sp1 (p1: type1, ...., pn: typen) : type_retour
var : variable_résultat : type_retour
début
......
Retourne (variable_résultat)
Fin
*******************************************************
Algorithme nom_algorithme
var : nom_variable : type_retour
début
....
nom_sp ( p1, p2, ...., pn)
....
nom_variable  nom_sp1 ( p1, p2, ...., pn)
Fin
#include <stdio.h>
void nom_sp (type1 p1, …,typen pn)
{
............
}
******************************************************
Type_retour nom_sp1 (type1 p1, …,typen pn)
{
Type_retour varaiuble_resultat ;
............
Return(variable_résultat)
}
******************************************************
void main()
{
Type_retour nom_varaiuble ;
.......
nom_sp (p1, …, pn) ;
Nom_varaible= nom_sp1 (p1, ..., pn) ;
. . ..
}
Passage des paramètres par valeur: Syntaxe 29
Dr.fadoua Bouafif
Ecrire un algorithme qui saisit deux valeurs entières et permute leur valeurs
30
Dr.fadoua Bouafif
Passage des paramètres par valeur: Exemple
Procédure Permuter(x, y :entier)
Var aux: entier
Début
aux  x
x  y
y  aux
Fin
*******************************************
Algorithme Permutation
Var A, B: entier
Début
Lire (A, B)
Permuter (A, B)
Ecrire (A, B)
Fin
Lors de l'appel de la procédure Permuter, le
paramètre x prend la valeur de A et le
paramètre y prend la valeur de B, à la fin de
l'exécution de la procédure x aura la valeur de B
et y la valeur de A
Mais… A et B n'ont pas changé de valeur
Cet algorithme ne résout pas notre problème
Solution:
on doit donner la possibilité à la procédure
permuter d'accéder aux adresses de A et B
pour pouvoir les modifier
Passage des paramètres par adresse: définition
Rappelons qu’une variable possède un nom et une adresse
 Dans ce type de passage, l'adresse des paramètres effectifs est associée aux paramètres
formels. Ainsi, toute modification apportée aux paramètres formels affecte les paramètres
effectifs.
 Lors de l'appel du sous programme, il y aura un envoi de l'adresse de la variable spécifiée pour
qu'il y aura des modifications du contenu mémoire de la variable déclarée, et donc il y a non
seulement copie des valeurs mais aussi transmission des variables.
 En algorithmique, les paramètres formels d'une fonction ne peuvent jamais être passés
par adresse.
31
Dr.fadoua Bouafif
En Algorithmique
procédure nom_sp (p1: type1, p2: type2, ...., pn: typen, var p11: type11, var p12: type12, ...., var p1n: type1n)
Var…….
debut
......
fin
****************************************************************************************************************************
Algorithme Nom_algorithme
var : ......
Début
....
nom_sp ( p1, p2, ...., pn, p11, p12, …, p1n)
....
fin
32
passage par valeur passage par adresse
Passage des paramètres par adresse:
Syntaxe en algorithme
Dr.fadoua Bouafif
29 30
31 32

9. 9
En C
void nom_sp (type1 p1, type2 p2, …., type11 *p11, type12 *p12, …, type1n *p1n)
{............}
****************************************************************************************************
Type_resultat nom_sp1(type1 p1, …, type2 *p6, ..., typen *pn)
{............}
*****************************************************************************************************
void main()
{
Type_resultat var_resultat ;
.......
nom_sp (p1,p2, …, &p11, &p12, …., &p1n) ;
var_resultat = nom_sp1 (p1,…, &p6, ..., &pn) ;
…
}
33
Passage des paramètres par adresse:
Syntaxe en C
passage par valeur passage par adresse
Dr.fadoua Bouafif
Passage des paramètres par adresse: Exemple
34
Lors de l'appel de la procédure Permuter,
le paramètre x prend l’adresse de A et le
paramètre y prend l’adresse de B.
À la fin de l'exécution de la procédure x
aura la valeur de B puisque x et A ont la
même adresse mémoire
De même y aura la valeur initiale de A
donc B aussi aura la valeur initiale de A
Donc A et B ont effectivement permutés
leurs valeurs
Ecrire un algorithme qui saisit deux valeurs entières et permute leur valeurs en utilisant le passage par adresse
Procédure Permuter(var x, y :entier)
Var aux:entier
Début
aux  x
x  y
y  aux
Fin
********************************
Algorithme Permutation
Var A, B :entier
Début
Lire (A, B)
Permuter (A, B)
Ecrire (A, B)
Fin
Activité
Écrire un algorithme (programme C) qui permet de saisir un tableau de taille N (0< N<=100)
d’entier et de calculer la somme de ses éléments.
On utilisera
 Un sous-programme « Taille_Tableau() » qui saisie la taille du tableau
 Un sous-programme « Remplir_Tableau() » qui saisie les éléments du tableau
 Un sous-programme « Calcul_Somme() » qui retourne la somme des éléments du tableau
35
Dr.fadoua Bouafif
Activité : Correction
36
Dr.fadoua Bouafif
33 34
35 36

10. 10
Conclusion
 Les différences entre les sous programmes procédure et fonction
 La déclaration explicite d'une procédure, en C, comme une fonction qui ne retourne aucune valeur
se fait à l'aide du mot clé void.
 Les paramètres données sont, en général, passés par valeur.
 Les paramètres données/résultats et résultats sont toujours passés par adresse.
 Un paramètre de type tableau est toujours passé par adresse, en C.
37
Procédure Fonction
Syntaxe Syntaxe
Appel Appel
Passage de paramètre par valeur Passage de paramètre par valeur
passage de paramètres par adresse passage de paramètres par adresse (uniquement en C)
Dr.fadoua Bouafif
37