Sous-programmes.

Présentation au sujet: "Sous-programmes."— Transcription de la présentation:

1 Sous-programmes

2 B.Shishedjiev -Sous-programmes
Les sous-programmes Définition – Le sous-programme est une partie de programme presque indépendante qui a un nom et peut être appelée d’un autre sous-programme ou du programme principal. Définition – description de l’algorithme avec paramètres formels (muets) Appel – exécution avec les paramètres effectifs Types Procédures – ne produit pas un résultat et son appel est une instruction Fonctions – produit une valeur comme résultat, donc son appel est une expression. B.Shishedjiev -Sous-programmes

3 B.Shishedjiev -Sous-programmes
Exemple début Définition val float fex(x,a,b,c) Paramètres formels x=1.5, a=4 n=3, p=2 q=10 val = ax2+bx+c Appel y = fex(x,a,n,p) return val Résultat fin afficher y z = fex(x+1,1,q,n-1) Paramètres effectifs afficher z fin B.Shishedjiev -Sous-programmes

4 B.Shishedjiev -Sous-programmes
Exemple en C #include <stdio.h> float fex(float, int,int,int); void main (void) { float x = 1.5; float y,z; int a=4, n=2, q = 7, p=3; y = fex(x,a,n,p); printf ("y = %8.3f\n",y); z = fex(x+1,1,q,n-1); printf ("z = %8.3f\n",z); } float fex(float x, int a,int b,int c){ float val, val1=3.4; val = a*x*x+b*x+c; return val; Déclaration Paramètres effectifs Appel Paramètres formels B.Shishedjiev -Sous-programmes Définition

5 Syntaxe Organigramme C Définition Appel
vg1,vg2.. vgn vl1,vl2,,,,,vln type nom_de_la_function (p1,p2,p3,..,pn) Algorithme fin C Définition type-de-retour nom-de-la-fonction ( type par1, type par 2, ..., type parn) { déclaration des variables locales ; instructions avec au moins une instruction return } Appel nom-de-la-fonction ( par1, par 2, ..., parn) B.Shishedjiev -Sous-programmes

6 Exécution du sous-programme
La pile du programme Enregistrement d’activation Exécution d’appel Créer l’EA Passer les paramètres Exécution des instructions Retour du contrôle Destruction de l’EA L’enregistrement de la fonction précédente pile paramètre n ... paramètre 1 Enregistrement d’activation adresse de retour variable locale 1 ... variable locale n B.Shishedjiev -Sous-programmes

7 Passage des paramètres
Passage par valeur pile programme appelant Sous-programme y ? 3 p(x) ... x=x+1 ; ... y=3 ; p(y) ; afficher(y) ; x=y x 4 ? 3 AR B.Shishedjiev -Sous-programmes

8 Passage des paramètres
Passage par adresse pile programme appelant Sous-programme ->adresse de y y 3 4 ? p(x) ... x=x+1 ; ... y=3 ; p(y) ; afficher(y) ; x ? AR B.Shishedjiev -Sous-programmes

9 B.Shishedjiev -Sous-programmes
Les fonctions en C Particularités le passage des paramètres est toujours par valeur on peut les appeler comme une instruction – le résultat n’est pas utilisé. on peut avoir une fonction sans résultat. L'appel est toujours une instruction on peut avoir une fonction sans paramètres printf ("%d",a); void nom(paramètres) type nom(void) B.Shishedjiev -Sous-programmes

10 B.Shishedjiev -Sous-programmes
Fonctions en C Exemple Faire une fonction qui trouve le pgcd de deux nombres entiers positifs. Ecrire un programme qui lit une suite de nombres et calcule le pgcd de chaque 2 nombres voisins. t,da,db int pgcd (a,b) début Lire x1 Initalisation da=a, db =b Lire x2 oui EOF t= da%db non da = db db = t d = pgcd(x1,x2) oui t0 afficher d non x1 = x2 return da fin fin B.Shishedjiev -Sous-programmes

11 B.Shishedjiev -Sous-programmes
Fonctions en C Exemple... #include <stdio.h> int pgcd( int ,int ); void main (void) { int x1, x2,r,d; do { printf ("tapez un nombre positif:"); scanf("%d", &x1); } while (x1 <= 0); while(1){ r = scanf("%d", &x2); } while (x2 <= 0); if ( r<1) break; d = pgcd(x1,x2); printf ("Le pgcd de %d et %d est %d\n", x1,x2,d); x1 = x2; } int pgcd( int a,int b){ int da, db, t; da = a; db = b; do{ t = da % db; da = db; db = t; }while (t!=0); return da; } B.Shishedjiev -Sous-programmes

12 Les paramètres résultat
En utilisant les pointeurs on obtient l'effet de passage par adresse pile y 4 3 ? #include <stdio.h> void p(int *x){ *x+=1 ; } void(main(void){ int y=3 ; p(&y) ; printf(“%d\n”,y) ; x @ ? AR B.Shishedjiev -Sous-programmes

13 Les paramètres résultat
Exemple Faire une fonction qui échange les valeurs de ces deux paramètres entiers. pile x1 ? 4 3 #include <stdio.h> void echange( int * ,int * ); void main (void) { int x1, x2; printf ("tapez deux nombres entiers:"); scanf("%d%d", &x1, &x2); printf ("Avant l'echange x1= %d et x2 = %d \n",x1,x2); echange(&x1,&x2); printf ("Apres l'echange x1= %d et x2 = %d \n",x1,x2); } void echange( int *a,int *b){ int t; t = *a ; *a = *b; *b = t; return ; x2 ? ? 4 3 a ? @ b @ ? AR t 3 ? B.Shishedjiev -Sous-programmes

14 Les paramètres résultat
Exemple – remanier le programme pgcd pour que la saisie ce fait par une fonction. int lirepositif(int *x) { int r; do { printf ("tapez un nombre positif:"); r = scanf("%d", x); } while (*x <= 0); return r; } int pgcd( int a,int b){ int da, db, t; da = a; db = b; do{ t = da % db; da = db; db = t; }while (t!=0); return da; #include <stdio.h> int pgcd( int ,int ); int lirepositif(int *); void main (void) { int x1, x2,r,d; lirepositif(&x1); while(1){ r=lirepositif(&x2); if ( r<1) break; d = pgcd(x1,x2); printf ("Le pgcd de %d et %d est %d\n", x1,x2,d); x1 = x2; } B.Shishedjiev -Sous-programmes

15 Les paramètres résultat
Exemple – remanier le programme pgcd pour que la saisie ce fait par une fonction. int lirepositif(void) { int r,x; do { printf ("tapez un nombre positif:"); r = scanf("%d", &x); } while (x <= 0); if (r>0) return x; else return -1; } int pgcd( int a,int b){ int da, db, t; da = a; db = b; do{ t = da % db; da = db; db = t; }while (t!=0); return da; #include <stdio.h> int pgcd( int ,int ); int lirepositif(void); void main (void) { int x1, x2,d; x1 = lirepositif(); while(1){ x2=lirepositif(); if ( x2<0) break; d = pgcd(x1,x2); printf ("Le pgcd de %d et %d est %d\n",x1,x2,d); x1 = x2; } B.Shishedjiev -Sous-programmes

16 Classes d’allocation Zones de mémoire la zone des variables statiques.
la zone des variables automatiques – la pile; la zone des variables dynamiques – le tas. pile tas Zone des variables statiques Enregistrement d'activation de main() Enregistrement d'activation de func1() ... Enregistrement d'activation de funcn() B.Shishedjiev -Sous-programmes

17 B.Shishedjiev -Sous-programmes
Les blocs Bloc Déclaration des variables En dehors de toute fonction En l'intérieur d'un bloc Des paramètres formels Variables par leur portée globales locales – ils peuvent masquer les globales paramètres { déclarations instructions exécutables } B.Shishedjiev -Sous-programmes

18 B.Shishedjiev -Sous-programmes
Portée des variables int globale ; //variable globale void main(void) { int local ; //variable locale global = 1 ; //on peut utiliser globale ici local = 2 ; // et locale aussi ( // début d’un bloc nouveau int plus_locale ; //c’est locale de ce bloc plus_locale=globale+locale ; } // le bloc interne est fermé //on ne peut plus utiliser plus_locale portée de globale portée de locale portée de plus_locale B.Shishedjiev -Sous-programmes

19 B.Shishedjiev -Sous-programmes
Masquer les variables int totale ; // nombre totale d’entrées int compteur ; //le nombre d’entrées void (main(void) { totale = 0 ; //variable locale compteur = 0 ; int compteur ; //compteur locale while (1) { if (compteur > 10) break ; totale += compteur ; ++ compteur; } portée de la variable globale compteur locale variable compteur cache la variable compteur globale B.Shishedjiev -Sous-programmes

20 B.Shishedjiev -Sous-programmes
L'attribut static L'attribut static a différente action variable locale – la portée de cette variable est le bloc où elle est définie mais sa durée de vie et toute l’exécution. variable globale Syntaxe static int k ; static type nom ; B.Shishedjiev -Sous-programmes

21 B.Shishedjiev -Sous-programmes
L'attribut static Exemple #include <stdio.h> int main() { int counter; /* compteur d'itérations */ for (counter = 0; counter < 3; ++counter) { int temporary = 1; /* variable temporelle*/ static int permanent = 1; /* variable permanente */ printf("Temporelle %d Permanente %d\n", temporary, permanent); ++temporary; ++permanent; } return (0); B.Shishedjiev -Sous-programmes

22 B.Shishedjiev -Sous-programmes
L'attribut static Exemple – une fonction qui compte les appels #include <stdio.h> int appels(void){ static int app; app++; return app; //rend le numéro d'appel } int main(void) { int counter; /* compteur d'itérations */ for (counter = 0; counter < 3; ++counter) { printf ("appel No %d \n", appels()); printf("Quel est ce nombre ? %d\n", appels()-appels()); return (0); B.Shishedjiev -Sous-programmes

23 B.Shishedjiev -Sous-programmes
Intialisation Variables globales 0 par défaut expression constante Variables locales par défaut – valeur indéfinie expression ordinaire Variables statiques – comme les variables globales B.Shishedjiev -Sous-programmes

24 B.Shishedjiev -Sous-programmes
Intialisation Exemple #include <stdio.h> #define N 5 int appels(int p1){ static int app = 2; // expression constante; int loc = p1 +1; // initialisation d’une variable automatique static int st1 = loc-1; // erreur – l’expression n’est pas constante static int j = N; // expression constante; app++; return app; } int main(void) { int counter ; /* compteur d'itérations ici sa valeur n’est pas définie*/ for (counter = 0; counter < 3; ++counter) { printf ("appel No %d \n", appels(counter)); printf("Quel est ce nombre ? %d\n", appels(3)-appels(4)); return (0); B.Shishedjiev -Sous-programmes

25 B.Shishedjiev -Sous-programmes
Récapitulation Type de variable Déclaration Portée Classe de mémoire Initialisation Globale En dehors de toute fonction la partie du fichier source suivant sa déclaration n’importe quel fichier source avec extern Statique Implicite – 0 Explicite – expression constante Globale cachée En dehors de toute fonction, avec attribut static Locale « remanente » Au début d’un bloc avec attribut static Le bloc Locale à une fonction Au début d’une fonction La fonction Automatique Implicite – il n’y a pas Explicite - Expression Locale à un bloc Au début d’un bloc B.Shishedjiev -Sous-programmes

26 B.Shishedjiev -Sous-programmes
L'attribut const Exemple #include <stdio.h> const int N=19; int appels(const int M){ static int app =M; //ici on peut initialiser – M est une constante int i; for (i=0; i<M; i++) printf("*"); M++; // erreur on ne peut pas modifier une constante printf("\n"); app++; return app; } int main(void) { N++; // erreur on ne peut pas modifier une constante printf("Quel est ce nombre ? %d\n", appels(3)-appels(5)); return (0); B.Shishedjiev -Sous-programmes

27 B.Shishedjiev -Sous-programmes
L'attribut const L'attribut const dans la déclaration d'un pointeur La différence entre #define et const p va toujours désigner i int i; int * const p = &i; La valeur désignée par p est constante int i=2; int const * p = &i; B.Shishedjiev -Sous-programmes