Langage c++

les fonctions en c++

I. Fonctions

1- Définition d’une fonction :

Le C++ ne permet de faire que des fonctions, pas de procédures. Une procédure peut être faite en utilisant une fonction ne renvoyant pas de valeur ou en ignorant la valeur retournée.

La définition des fonctions se fait comme suit :

type identificateur(paramètres)
 {
    /* Instructions de la fonction */
 }
  • Type: le type de la valeur renvoyée;
  • Identificateur: le nom de la fonction;
  • Paramètres: la liste de paramètres.

Remarque : L’initialisation des paramètres de fonctions n’est possible qu’en C++, le C n’accepte pas cette syntaxe.

La valeur de la fonction à renvoyer est spécifiée en utilisant la commande return,dont la syntaxe est : return valeur.

Exemple d’une fonction en C++:

  int somme(int i, int j)
  {
     return i+j;
  }

Si une fonction ne renvoie pas de valeur, on lui donnera le type void. Si elle n’attend pas de paramètres, sa liste de paramètres sera void ou n’existera pas. Il n’est pas nécessaire de mettre une instruction return à la fin d’une fonction qui ne renvoie pas de valeur.

2- Définition d’une procédure :

Exemple d’une procédure en C++:

  void rien()     /* Fonction n’attendant pas de paramètres */
  {               /* et ne renvoyant pas de valeur. */
      return;     /* Cette ligne est facultative.
  }

3- Appel d’une fonction:

L’appel d’une fonction se fait en donnant son nom, puis les valeurs de ses paramètres entre parenthèses.

S’il n’y a pas de paramètres, il faut quand même mettre les parenthèses, sinon la fonction n’est pas appelée.

Si la déclaration comprend des valeurs par défaut pour des paramètres (C++seulement), ces valeurs sont utilisées lorsque ces paramètres ne sont pas fournis lors de l’appel. Si un paramètre est manquant, alors tous les paramètres qui le suivent doivent eux aussi être omis. Il en résulte que seuls les derniers paramètres d’une fonction peuvent avoir des valeurs par défaut.

Exemple d’une fonction:

  int test(int i =0, int j =2)
  {
     return i/j;
  }

L’appel de la fonction test(8) est valide. Comme on ne précise pas le dernier paramètre, j est initialisé à 2. Le résultat obtenu est donc 4. De même,l’appel test() est valide : dans ce cas i vaut 0 et j vaut 2. En revanche, ilest impossible d’appeler la fonction test en ne précisant que la valeur de j.Enfin, l’expression « int test(int i=0,int j) {...} » serait invalide, car sinon ne passait pas deux paramètres, j ne serait pas initialisé.

4- Déclaration d’une fonction:

Toute fonction doit être déclarée avant d'être appelée pour la première fois.
Il peut se trouver des situations où une fonction doit être appelée dans une autre fonction définie avant elle. Comme cette fonction n'est pas définie au moment de l'appel, elle doit être déclarée. Le rôle des déclarations est doncde signaler l'existence des fonctions aux compilateurs afin de les utiliser, tout en reportant leur définition plus loin ou dans un autre fichier.

Exemple de déclaration d’une fonction:

  int Min(int, int);               /* Déclaration de la fonction minimum */ 
  int main(void){               /* Fonction principale.*/ 
     int i = Min(2,3); /* Appel à la fonction Min, déjà déclarée. */ 
     return 0; 
  } 

  int Min(int i, int j) {         /* Définition de la fonction min. */ 
     if (i<j) return i; 
     else return j;
  } 

5- Surcharge d’une fonction:

Il est donc possible de faire des fonctions de même nom (surcharge) si etseulement si toutes les fonctions portant ce nom peuvent être distinguées par leurs signatures. La surcharge qui sera appelée sera celle dont la signature est la plus proche des valeurs passées en paramètre lors de l'appel. 

Exemple d’une surcharge d’une fonction:

  float test(int i, int j)   { 
     return (float) i+j; 
  } 

  float test(float i, float j) 
  { 
     return i*j;
  } 

Ces deux fonctions portent le même nom, et le compilateur les acceptera toutes les deux. 

  • Lors de l'appel de test(2,3)à la 1ère fonction est appelée (2 et 3 sont des entiers). 
  • Lors de l'appel de test(2.5,3.2) à la 2ème fonction est appelée (2.5 et 3.2 sont réels).
  •  Lors de l’appel de test(2.5,3) à la 1ère fonction est appelée ( le flottant 2.5 sera converti en entier). 

6- Fonctions inline: 

Une fonction en ligne se définit et s'utilise comme une fonction ordinaire, à la seule différence qu'on fait précéder son entête de la spécification inline. 

Le mot inline indique au compilateur de remplacer au sein du programme les appels de la fonction par les instructions compilées (c'est-à-dire en langage machine) du corps de la fonction. Cela permet de réduire le temps d'appel de la fonction. En revanche, les instructions correspondantes au corps de la fonction sont générées à chaque appel de la fonction, ce qui consomme une quantité de mémoire croissante avec le nombre d'appels.

  • Le code de la fonction inline est inséré à la place de chaque appel ;
  • La fonction est intéressante pour des petites fonctions ;
  • Le compilateur peut l’implémenter comme une fonction classique.

Exemple:

inline int Max(int i, int j)
{
   if (i>j) return i; 
   else return j; 
}
void main(){
   int x=5,res,  y=2 ;
   res =max( x, y) ;
}

II. Passage de paramètres 

1. Passage par valeur :

Lors du passage par valeur, les arguments sont copiés dans des objets temporaires qui sont crées lors du passage d'arguments et qui sont détruit à la fin de l'exécution de la fonction : toutes les modifications effectuées sur ces objets temporaires seront donc perdues à la fin de la fonction et n'auront aucune incidence sur l'objet passé en argument lors de l'appel de la fonction.

Exemple de passage par valeur:

void incremente(int i) 
{ i++; }

int main()
{
    int j = 12;
    incremente(j);
    cout << j << endl; // Affiche 12 
}                                 l’échange n’a pas lieu

2. Passage par adresse :

Dans le passage par adresse, on manipule des pointeurs (c'est le passage d'arguments classique du C lorsqu'on veut modifier les arguments) : les arguments sont des pointeurs qui contiennent l'adresse en mémoire des objets que l'on veut manipuler. Il n'y a qu'une copie de pointeur lors du passage par adresse.

Exemple de passage par adresse:

void incremente(int * i)
{ (*i)++; }
int main() 
{
   int j = 12; incremente(&j); 
   cout << j << endl; // Affiche 13 
}                   

3. Passage par référence :

En C, la notation &n signifie l’adresse de la variable n.

En C++, cette notation possède deux significations:

  • Il peut toujours s’agir de l’adresse de la variable n;
  • Il peut aussi s’agir de la référence à n.

Seulement le contexte du programme permet de déterminer, s’il s’agit de l’une ou l’autre des deux significations. 

Exemple:

int n ;
int &p=n; // p est une référence à n
                //p occupe le même emplacement mémoire que n 
n=3;
cout<<p; // l’affichage donnera 3

En C,comme en C++ , un sous programme ne peut modifier  la valeur d’une variable locale passée en argument de fonction. Pour se faire, en C, il faut passer l’adresse de la variable. En C++, on préférera le passage par référence.

Le C++ permet le passage par référence : la fonction appelée manipule directement l'objet qui lui est passé par référence (cela correspond au var du langage Pascal). Il n'y a pas de copie ni de construction d'objet temporaire lors de passage par référence.

Exemple de passage par référence :

void incremente(int& i) 
{ i++; } 
int main() 
{ 
   int j = 12; incremente(j); 
   cout << j << endl; // Affiche 13, l’échange a lieu 
}                              

Lorsqu'on manipule de gros objets (des matrice,...), il est particulièrement intéressant d'effectuer des passages par référence. 


Partager ce cours avec tes amis :
Rédigé par Mostafa Sedoki
Professeur d'Informatique dans les CPGE

Cours Similaires :