Télécharger en tant que PDF, PPTX
ch6 les sous programmes.pdf
- 1. 1 1 Algorithmique & structures dedonné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 manipulationet 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édureest 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 unalgorithme (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 EnC 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 sousprogramme 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 EnC 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érencesentre 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