Les fonctions

Déclaration/Prototypes C’est une instruction fournissant au compilateur des infos sur une fonction qu’on envisage d’appeler par le suite C tolère une déclaration réduite, source d’erreurs. –float *fct(int n, char c, double *d); //ANSI –float *fct(int, char, double *);//ANSI –float *fct();//PAS ANSI Appel en cas d’absence: par défaut, on suppose une déclaration int g() (ce qui peut impliquer des conversions implicites!!!)

Définition C’est l’ensemble des instructions qui précisent les actions à exécuter lors de son appel. Constitué de deux parties: –Une en-tête –Un corps formé d’un bloc d’instructions… Initiale: float poly(x,b,c) float x; int b,c; { } ANSI: float poly(float x, int b, int c){ }

Définition (2) Les arguments apparaissant dans l’en-tête peuvent être de tout type. Lors de leur déclaration, on peut compléter leur type avec des qualifieurs (const, register, …) float fct(register int p, const double df); Une fonction sans argument : float tirage(void){…} ( ou float tirage(){…} )

Passage d’arguments par valeur Valeur d’une variable simple: void impression(int x; int y){ printf(``(%d,%d)\n``,x,y); } int i, j, t[TAILLE]; impression(6,2); impression(i, j); impression(3*i+j, t[i]); Un appel par valeur: la fonction fait une copie de l’argument et la met dans une variable locale à la fonction.

Attention! Comme le C passe les arguments des fonctions par valeurs, la fonction appelée n’a aucun moyen direct de modifier une variable de la fonction appelante! Mauvais exemple: echange(a,b); void echanger(int x, int y){ int temp; temp = x; x = y; y = temp; } Bon exemple: echange(&a,&b); Void echange(int *px, int *py){ int temp; temp = *px; *px = *py; *py = temp; }

Passage de types complexes struct point {int x,y}; void lect1(int *p_a, int *p_b); void lect2(point *p_pt); void main(void){ struct point pt1, pt2; lect1(&(pt1.x),&(pt1.y)); lect2(&pt2); } void lect1(int *pa, int *pb){ printf(``abscisse: ``); scanf(``%d``,pa); printf(``ordonnée: ``); scanf(``%d``,pb); } void lect2(point *pt){ printf(``abscisse: ``); scanf(``%d``,&(pt  x)); }

Tableau en paramètre d’une fonction Le passage par valeur d’un tableau n’existe pas en langage C: seule l’adresse de début de zone mémoire où sont stockées les valeurs est passé à la fonction appelée (rappel: tableau == pointeur) Donc il est inutile de préciser la taille totale du tableau lors de la déclaration de la fonction void affiche(char ch[]); void affiche(char ch*); (rappel la vraie nature) Mais: void affiche(char ch[][10]); Pour que la fonction puisse calculer l’adresse d’un élément. ch[i][j] est équivalent à *(ch+i*10+j)

Fonction passée en paramètre d’une fonction Ex:void fct_save(void (fct) (int), int masque){ … fct(masque); … } Appel par: fct_save(maFonction,2); Exemple: int incr(int a); fct_save(int (incr)(int), 34);

La valeur de retour (1) type nom_fonction(liste_argument){instructions;} Le type retourné peut être tout type simple, une structure ou un pointeur. Ne peut retourner de tableau ni de fonction. (mais un pointeur sur une fonction). Une fonction ne peut retourner qu’une seule valeur. Quand une fonction ne retourne pas de valeur, mettre le type void.

Valeur de retour La déclarer, avec presque tout les qualificateurs: const int *maFonction(int p, double v); Ne peut renvoyer de fonctions, de tableaux (zones mémoires statiques) ou de valeur const. Mais peut renvoyer des pointeurs dessus. En absence de valeur de retour, utiliser void int *f (double n); int ( *f (int, char) )[5];

Les blagues Exemple: int incr(int a){return(++a);} Ne pas retourner en résultat un pointeur sur une zone mémoire dont le programme n’a plus le contrôle. Incorrect: int *f(int x){ int taille[TAILLE]; return(table); } Correct: déclarer le tableau comme une variable static int *f(int a){ static int table[TAILLE]; return(table); } Correct: allouer dynamiquement si on veut un nouveau tableau ) chaque fois. int *f(int a){ int *p; p=(int*)malloc(TAILLE*sizeof(int)); return(p); }

Corrigez: int nb_jour[13]; void init(nb_jour tab){ … } int ajoute(int x, int y, int z){ return(z = x + y); }