====== Les fonctions surchargées ======

===== Les limitations de la déclaration en C =====

En C, chaque fonction doit avoir un nom différent. Si deux fonctions ont le même nom, alors, le compilateur va générer une erreur. 

Cette limitation empêche de pouvoir écrie du code facilement lisible. Ainsi supposons que nous souhaitons définir une fonction identité, il faudrait écrire pour chaque type d'argument un nom de fonction différent :

<code c>
int id_int(int x) { return x; }
int id_float(float x) { return x; }
int id_double(double x) { return x; }
int id_unsigned(unsigned x) { return x; }
</code>

===== La notion de surcharge =====

Un nom de fonction est surchargé si ce nom désigne non pas une fonction mais plusieurs fonctions qui différent seulement par la liste des arguments. Alors comment le compilateur peut savoir quelle fonction il doit appeller, simplement en regardant la liste des arguments et le type des arguments :

<code cpp>
int id(int x) { return x; }
int id(float x) { return x; }
int id(double x) { return x; }
int id(long x) { return x; } 
</code>

Dans le cas présent, en fonction de l'argument, si ''x'' est ''int'', alors le compilateur appellera la fonction ''id(int)'', si ''x'' est ''float'', il appellera la fonction ''id(float)'', ainsi de suite.

Cependant, on peut avoir des soucis. Par exemple, si nous appellons ''id('a')'', le caractère 'a' peut-être converti en ''int'' ou en ''long''. Dans ce cas, le compilateur va indiquer que plusieurs fonctions ayant le nom ''id'' peuvent être appelées. Il faut donner une information sur la bonne fonction en spécifiant le type des paramètres. Pour l'exemple, précédent, il suffit d'écrire : ''id((int)'a')''. Dans ce cas, ce sera la fonction ''id(int)'' qui sera appellée.