Sous-programmes

1. Sous-programmes

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

4. 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 Algorithme fin vg1,vg2.. vgn vl1,vl2,,,,,vln type nom_de_la_function (p1,p2,p3,..,pn) • Organigramme • 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 3 y ? p(x) ... x=x+1 ; ... x=y ... y=3 ; p(y) ; afficher(y) ; ... 3 4 x ? AR B.Shishedjiev -Sous-programmes

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

9. 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. Fonctions en C t,da,db int pgcd (a,b) • 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. 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. 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){ do { printf ("tapez un nombre positif:"); 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 3 4 y ? #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 • ExempleFaire une fonction qui échange les valeurs de ces deux paramètres entiers. pile 3 x1 ? 4 #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 ; } ? ? 3 4 x2 a ? @ ? b @ AR 3 t ? 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. 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. 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. 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 compteur = 0 ; while (1) { if (compteur > 10) break ; totale += compteur ; ++ compteur; } } ++ compteur; } portée de la variable globale compteur locale variable compteur cache la variable compteur globale B.Shishedjiev -Sous-programmes

20. 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 ; statictypenom ; B.Shishedjiev -Sous-programmes

21. 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. 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. 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. 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. Récapitulation B.Shishedjiev -Sous-programmes

26. 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. 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