• Fonctions (suite)

C-IV  1

1. Pile d'exécution
2. Passage d'arguments par référence
3. Retour d'une fonction et références
4. Signature vs. Prototype
5. Surcharge d'une fonction
6. Fonctions inline
7. Récursion

C-IV  2

• Utilisation des pointeurs et de l'opérateur &.
  
  
  

  void	echange2(int* a, int* b) {
  int tmp = *a;
  *a=*b; *b = tmp; }

  
  Appel de echange2 par

  int x,y;

  echange2(&x, &y);

  
  
• Utilisation des références.
  
  

  void	echange3(int &a, int &b) {
  int tmp = a;
  a=b; b = tmp; }

  Appel de echange3 par

  int x,y;

  echange3(x, y);

C-IV  3

• Attention : lorsqu'une fonction retourne une référence, une LVALUE non-locale à la fonction doit être retournée.

C-IV  4

• Signature : nom de la fonction, nombre et type des arguments (mais pas le type de retour).
  Le type d'une fonction (ou d'un pointeur sur fonction) est déterminé par la signature :
  int (* copier) (char *, const char *);
  
  
  
  
• Prototype : signature de la fonction + le type du retour de la fonction.
  La DEFINITION et la DECLARATION d'une fonction se fait par prototype :
  int getAge(File *infile, char *name);
  Remarque : dans la déclaration, les NOMS des arguments sont facultatifs.

  int lookup(char *id, int n);

  // L'écriture suivante est également

  // possible

  int lookup(char *, int);

C-IV  5

• la surcharge d'une fonction est réalisée à partir de la signature (possible uniquement en C++).
  
  

  // Fonction valeur absolue

  // pour les doubles

  double abs(double d);

  // Nvelle fonction valeur absolue

  // pour les entiers

  int abs(int d);

  MAIS
  

  // Fonction arrondi pour les flottants

  float arrondi(float d);

  // Erreur : surcharge impossible

  // car la fonction arrondi a la

  // MEME signature !!!

  int arrondi(float d);

C-IV  6

• Le mot-clé inline est utilisé pour signifier au compilateur que la définition de la fonction doit (si possible) remplacer tout appel à cette fonction.

  inline	int min(int x,int y)
  { return (x<y?x:y); }

• Les fonctions inline combinent l'efficacité des macros avec la vérification de type et l'abstraction d'un appel de fonction.
• Les fonctions inline réduisent le temps d'exécution.
• A utiliser pour des fonctions PETITES et appelées souvent (pas de boucles),
• Les fonctions récursives ne peuvent pas être expansées Þ les déclarer inline ne sert à rien.

C-IV  7

• Définition de macro en C :

  #define Square(x) ((x) * (x))

  int a = 10;

  int b = Square(a++);

  // pb!!! (a++) * (a++)

• Réécriture avec une fonction inline en C++ :

  inline int Square(int x)

  { return x * x;}

  int c = Square(a++); // OK

  Remarque : La macro fonctionnait pour tout type d'argument. On verra plus loin que l'on peut le faire aussi avec une fonction ``template''.