|
 |
On appelle fonction un sous-programme qui permet d'effectuer un ensemble d'instruction par simple appel de la fonction dans le corps du programme principal. Les fonctions permettent d'exécuter dans plusieurs parties du programme une série d'instructions, cela permet une simplicité du code et donc une taille de programme minimale. D'autre part, une fonction peut faire appel à elle-même, on parle alors de fonction récursive (il ne faut pas oublier de mettre une condition de sortie au risque sinon de ne pas pouvoir arrêter le programme...).
Avant d'être utilisée, une fonction doit être définie car pour l'appeler dans le corps du programme il faut que le compilateur la connaisse, c'est-à-dire qu'il connaisse son nom, ses arguments et les instructions qu'elle contient. La définition d'une fonction s'appelle "déclaration". La déclaration d'une fonction se fait selon la syntaxe suivante:
type_de_donnee Nom_De_La_Fonction(type1 argument1, type2 argument2, ...) {
liste d'instructions
}
Remarques:
Pour exécuter une fonction, il suffit de faire appel à elle en écrivant son nom (une fois de plus en respectant la casse) suivie d'une parenthèse ouverte (éventuellement des arguments) puis d'une parenthèse fermée: Nom_De_La_Fonction(); Remarques:
Le prototype d'une fonction est une description d'une fonction qui est définie plus loin dans le programme. On place donc le prototype en début de programme (avant la fonction principale main()). Cette description permet au compilateur de "vérifier" la validité de la fonction à chaque fois qu'il la rencontre dans le programme, en lui indiquant:
Contrairement à la définition de la fonction, le prototype n'est pas suivi du corps de la fonction
(contenant les instructions à exécuter), et ne comprend pas le nom des paramètres (seulement leur type).
Type_de_donnee_renvoyee Nom_De_La_Fonction(type_argument1, type_argument2, ...);
Voici quelques exemples de prototypes: void Affiche_car(char, int); int Somme(int, int);
Il est possible de passer des arguments (appelés aussi paramètres à une fonction, c'est-à-dire
lui fournir une valeur ou le nom d'une variable afin que la fonction puisse effectuer
des opérations sur ces arguments ou bien grâce à ces arguments.
Le nombre et le type d'arguments dans la déclaration, le prototype et dans l'appel doit correspondre au risque, sinon, de génerer une erreur lors de la compilation... Un argument peut être:
Il arrive généralement que l'on ait à passer souvent une même
valeur en paramètre à une fonction. Ainsi, pour simplifier les appels de fonctions
comportant un paramètre qui varie peu, le langage C++ permet de déclarer des valeurs
par défaut dans le prototype de la fonction, par exemple:
void fonction(int parametre1, char parametre2, float parametre3=4.5);
void main() {
char c='a';
fonction(8,c);
}
void fonction(int parametre1, char parametre2, float parametre3){
cout << parametre1 << parametre2 << parametre3;
}
(la fonction cout permet d'afficher parametre1, parametre2, et parametre3)
La fonction peut renvoyer une valeur (et donc se terminer) grâce au mot-clé return. Lorsque l'instruction return est rencontrée, la fonction évalue la valeur qui la suit, puis la renvoie au programme appelant (programme à partir duquel la fonction a été appelée). Une fonction peut contenir plusieurs instructions return, ce sera toutefois la première instruction return rencontrée qui provoquera la fin de la fonction et le renvoi de la valeur qui la suit. La syntaxe de l'instruction return est simple: return valeur_ou_variable;
Le langage C++ introduit le concept de fonction inline en ajoutant le mot clé inline. Ce mot clé permet de définir des fonctions qui seront directement évaluées à la compilation, et dont l'appel dans le programme sera remplacé par la valeur évaluée. Ce concept de pseudo-fonction était déjà possible en langage C, grâce à la directive de préprocesseur #define. Toutefois cette directive ne permettait aucun contrôle de type, ce que le mot clé inline réalise... Voici un exemple présentant la syntaxe de l'instruction:
inline int Double(int a);
void main(){
int b = 3;
b = Double(b);
}
inline int Double(int a){
return 2*a;
}
Un des apports les plus intéressants du C++ par rapport au C, hormis l'ajout du
concept objet, est la possibilité d'appeler plusieurs fonctions avec le même
nom, pour peu que celle-ci aient leurs arguments différents (en type et/ou en nombre).
En effet, une fonction est déterminé par ce que l'on appelle sa signature, c'est-à-dire:
Il est ainsi possible de définir une fonction réalisant la même opération sur des variables différentes en nombre ou en type:
int somme( int p1, int p2){
return (p1 + p2);
}
float somme( float p1, float p2){
return (p1 + p2);
}
float somme( float p1, float p2, float p3){
return (p1 + p2 + p3);
}
int somme( float p1, int p2){
return (int(p1) + p2);
}
|
