Programmation C++/Les fonctions
Utilisation des fonctions
[modifier | modifier le wikicode]Le C++ est un langage procédural (entre autres paradigmes), on peut définir des fonctions qui vont effectuer une certaine tâche. On peut paramétrer des fonctions qui vont permettre de paramétrer cette tâche et rendre ainsi les fonctions réutilisables dans d'autres contextes.
Exemple général trivial :
#include <iostream>
using namespace std;
int doubleur(int a_locale_doubleur) // Mise en évidence facultative mais très pédagogique de la portée locale de la variable.
{
return 2*a_locale_doubleur;
}
int main()
{
int nombre = 21;
cout << doubleur(nombre) << endl; // 42.
return 0;
}
Compléments indispensables pour les débutants
[modifier | modifier le wikicode]- On indique devant le nom de la fonction la nature du
return
:int
,string
,char
,double
... (void
en l'absence dereturn
). - Les variables définies localement restent locales. On peut ajouter au nom de la variable un affixe comme au début de la page, avec par exemple
_locale_
et le nom de la fonction, pour plus de facilité de relecture pour les grands débutants, mais cela n'est pas habituel. - Une fonction pourra appeler d'autres fonctions et ainsi de suite.
- Une fonction peut même s'appeler elle-même : on parle alors de fonctions récursives.
- Limitations ("Ce ne sont pas des bugs, ce sont des fonctionnalités !") actuelles du C++ :
- Le
return
peut être un tableau (c'est-a-dire que la fonction peut renvoyer un tableau). - Le
return
renvoie une seule valeur.
- Le
Prototype d'une fonction
[modifier | modifier le wikicode]Le prototype va préciser le nom de la fonction, donner le type de la valeur de retour de la fonction (void
quand il n'y a pas de retour), et donner les types des paramètres éventuels, ainsi que leurs éventuelles valeurs par défaut. Le prototype d'une fonction est facultatif. Si on ne met pas de prototype, on devra rédiger la fonction avant le main, au lieu de la rédiger après ou dans un fichier séparé (extension .h
).
syntaxe
[modifier | modifier le wikicode]type identificateur(paramètres);
Exemple
[modifier | modifier le wikicode]// prototype de la fonction f :
double f(double x,double y);
Rôle
[modifier | modifier le wikicode]Le rôle d'un prototype n'est pas de définir les instructions de la fonction, mais donner sa signature. Il est utilisé pour spécifier que la fonction existe, et est implémentée ailleurs (dans un autre fichier, une librairie, ou à la fin du fichier source).
On les trouve principalement dans les fichiers d'en-tête (extension .h
).
Définition d'une fonction
[modifier | modifier le wikicode]La définition va reprendre le prototype mais va préciser cette fois le contenu de la fonction (le corps).
Syntaxe
[modifier | modifier le wikicode]type identificateur(paramètres) { ... Liste d'instructions ... }
Exemple
[modifier | modifier le wikicode]#include <iostream>
using namespace std;
// définition de la fonction f :
double f(double x, double y)
{
double a;
a = x*x + y*y;
return a;
}
int main()
{
double u, v, w;
cout << "Tapez la valeur de u : "; cin >> u;
cout << "Tapez la valeur de v : "; cin >> v;
w = f (u, v); //appel de notre fonction
cout << "Le résultat est " << w << endl;
return 0;
}
Exemple avec prototype
[modifier | modifier le wikicode]#include <iostream>
using namespace std;
// prototype de la fonction f :
double f(double x, double y);
int main()
{
double u, v, w;
cout << "Tapez la valeur de u : "; cin >> u;
cout << "Tapez la valeur de v : "; cin >> v;
w = f (u, v); //appel de notre fonction
cout << "Le résultat est " << w << endl;
return 0;
}
// définition de la fonction f :
double f(double x, double y)
{
double a;
a = x*x + y*y;
return a;
}
Dans cet exemple, le prototype est nécessaire, car la fonction est définie après la fonction main
qui l'utilise. Si le prototype est omis, le compilateur signale une erreur.
Portée des variables
[modifier | modifier le wikicode]Présentation
[modifier | modifier le wikicode]Une fonction peut accéder :
- à ses différents paramètres,
- à ses variables définies localement,
- aux variables globales (on évitera au maximum d'utiliser de telles variables).
On appelle environnement d'une fonction l'ensemble des variables auxquelles elle peut accéder. Les différents environnements sont donc largement séparés et indépendants les uns des autres. Cette séparation permet de mieux structurer les programmes.
Exemple
[modifier | modifier le wikicode]#include <iostream>
using namespace std;
int b; // variable globale
double f(double x, double y)
{
double a; // variable locale à la fonction f
a = x*x + y*y;
return a;
}
double g(double x)
{
int r, s, t; // variables locales à la fonction g
/* ... */
}
int main()
{
double u, v, w; // variables locales à la fonction main
/* ... */
return 0;
}
b
est une variable globale (à éviter : une structure la remplace avantageusement !).f
peut accéder- à ses paramètres
x
ety
. - à sa variable locale
a
. - à la variable globale
b
.
- à ses paramètres
g
peut accéder- à son paramètre
x
. - à ses variables locales
r
,s
ett
. - à la variable globale
b
.
- à son paramètre
- la fonction
main
peut accéder- à ses variables locales
u
,v
etw
. - à la variable globale
b
.
- à ses variables locales
Passage de paramètres par pointeur
[modifier | modifier le wikicode]Passer un paramètre par pointeur permet de modifier la valeur pointée en utilisant l'opérateur de déréférencement *
.
Pour passer un pointeur comme argument de fonction, il faut en spécifier le type dans la définition de la fonction et (si pertinent), dans le prototype de la fonction, comme ceci :
void passagePointeur(int *); // Prototype d'une fonction renvoyant void
// et prenant comme argument un pointeur vers un int
void passagePointeur(int * ptr) // Définition d'une fonction renvoyant void
// et prenant comme argument un pointeur vers un int appelé ptr
{
/* ... */
}
De même, il faut, lors de l'appel de fonction, non pas spécifier le nom de la variable comme lors d'un passage par valeur, mais son adresse. Pour ceci, il suffit de placer le signe & devant la variable.
int a = 5; // Initialisation d'une variable a, de valeur 5
passageValeur( a ); // Appel d'une fonction par valeur
passagePointeur( &a ); // Appel d'une fonction par pointeur
Notez donc le & devant la variable, ceci a pour effet de passer l'adresse mémoire de la variable.
Examinons le programme simple suivant :
#include <iostream>
using std::cout;
void passagePointeur(int *);
void passageValeur(int);
int main()
{
int a = 5;
int b = 7;
cout << "a : " << a << endl;
cout << "b : " << b; // Affiche les deux variables
passageValeur (a); // Appel de la fonction en passant la variable a par valeur
// Une copie de la valeur est transmise à la fonction
passagePointeur (&b); // Appel de la fonction en passant l'adresse de la variable b par pointeur
// Une copie de l'adresse est transmise à la fonction
cout << endl;
cout << "a : " << a << endl;
cout "b : " << b; // Réaffiche les deux variables
system ("PAUSE");
return 0;
}
void passagePointeur(int * ptr)
{
int num = 100;
cout << endl;
cout "*ptr : " << *ptr; // Affiche la valeur pointée
* ptr = 9; // Change la valeur pointée;
ptr = # // <-- modification de l'adresse ignorée par la fonction appelante
}
void passageValeur(int val)
{
cout << endl;
cout "val : " << val;
val = 12; // <-- modification de la valeur ignorée par la fonction appelante
}
On affiche les deux variables puis on appelle les deux fonctions, une par valeur et une par pointeur. Puis on affiche dans ces deux fonctions la valeur et on modifie la valeur. De retour dans main, on réaffiche les deux variables a et b. a, qui a été passée par valeur, n'a pas été modifiée et a toujours sa valeur initiale (5), spécifiée à l'initialisation. Or, b n'a plus la même valeur que lors de son initialisation, 7, mais la valeur de 9. En effet, lors d'un appel par valeur, une copie de cette valeur est créée, donc lorsqu'un appel de fonction par valeur est effectué, on ne modifie pas la valeur d'origine mais une copie, ce qui fait que lorsqu'on retourne dans la fonction d'origine, les modifications effectuées sur la variable dans la fonction appelée ne sont pas prises en comptes. En revanche, lors d'un appel par pointeur, il s'agit de la variable elle même qui est modifiée (puisqu'on passe son adresse). Donc si elle est modifiée dans la fonction appelée, elle le sera également dans la fonction appelante.
Les avantages sont que cet appel nécessite moins de charge de travail pour la machine. En effet, par valeur, il faut faire une copie de l'objet, alors que par pointeur, seule l'adresse de l'objet est copiée. L'inconvénient, c'est qu'on peut accidentellement modifier dans la fonction appelée la valeur de la variable, ce qui se répercutera également dans la fonction appelante. La solution est simple : il suffit d'ajouter const dans le prototype de fonction de cette manière :
void passagePointeur(const int *);
// En d'autres termes, un pointeur vers un int constant
ainsi que la définition de fonction comme ceci :
void passagePointeur(const int * ptr)
{
// * ptr = 9; // <- maintenant interdit
}
En recompilant le programme mis plus haut avec ces deux choses, on constate un message d'erreur indiquant que l'on n'a pas le droit de modifier une valeur constante.
Passage de paramètres par référence
[modifier | modifier le wikicode]Passer un paramètre par référence a les mêmes avantages que le passage d'un paramètre par pointeur. Celui-ci est également modifiable. La différence est que l'opérateur de déréférencement n'est pas utilisé, car il s'agit déjà d'une référence.
Le passage de paramètre par référence utilise une syntaxe similaire au passage par pointeur dans la déclaration de la fonction, en utilisant &
au lieu de *
.
Par exemple :
void incrementer(int& value)
// value : référence initialisée quand la fonction est appelée
{
value++;
// la référence est un alias de la variable passée en paramètre
}
void test()
{
int a = 5;
cout << "a = " << a << endl; // a = 5
incrementer(a);
cout << "a = " << a << endl; // a = 6
}
Le paramètre ainsi passé ne peut être qu'une variable.
Sa valeur peut être modifiée dans la fonction appelée, à moins d'utiliser le mot const
:
void incrementer(const int& value)
{
value++; // <- erreur générée par le compilateur
}
void test()
{
int a = 5;
cout << "a = " << a << endl;
incrementer(a);
cout << "a = " << a << endl;
}
La question que l'on peut se poser est puisque le passage par référence permet de modifier le paramètre, pourquoi l'en empêcher, et ne pas utiliser un simple passage par valeur ?
La réponse se trouve lorsqu'on utilise des objets ou des structures.
Le passage par valeur d'un objet ou d'une structure demande une recopie de la valeur de ses membres (utilisant un constructeur de recopie pour les objets).
L'avantage de passer une référence est d'éviter la recopie. Le mot const
permet de garantir qu'aucun membre de l'objet ou de la structure n'est modifié par la fonction.
Pointeur de fonction
[modifier | modifier le wikicode]Un pointeur de fonction stocke l'adresse d'une fonction, qui peut être appelée en utilisant ce pointeur.
La syntaxe de la déclaration d'un tel pointeur peut paraître compliquée, mais il suffit de savoir que cette déclaration est identique à celle de la fonction pointée, excepté que le nom de la fonction est remplacé par (* pointeur)
.
Obtenir l'adresse d'une fonction ne nécessite pas l'opérateur &
. Il suffit de donner le nom de la fonction seul.
Exemple :
#include <iostream>
#include <iomanip>
using namespace std;
int (* pf_comparateur)(int a, int b);
// peut pointer les fonctions prenant 2 entiers en arguments et retournant un entier
int compare_prix(int premier, int second)
{
return premier - second;
}
int main()
{
pf_comparateur = &compare_prix;
cout << "compare 1 et 2 : " << (*pf_comparateur)(1, 2) << endl;
return 0;
}
La syntaxe d'appel à une fonction par un pointeur est identique à l'appel d'une fonction classique.
Passage de fonctions en paramètre
[modifier | modifier le wikicode]Il s'agit en fait de passer un pointeur de fonction.
Exemple :
void sort_array( int[] data, int count, int (* comparateur_tri)(int a, int b) );
Pour clarifier la lecture du code, il est préférable d'utiliser l'instruction typedef
:
typedef int (* pf_comparateur)(int a, int b);
void sort_array( int[] data, int count, pf_comparateur comparateur_tri );
Exercices
[modifier | modifier le wikicode]Exercice 1
[modifier | modifier le wikicode]Créez une fonction factorielle
pour calculer la factorielle d'un entier n.
Elle retourne un entier long.
Créez une fonction non récursive.
La factorielle (noté ! en mathématiques) se définit ainsi :
!1 = 1 = 1
!2 = 2 x 1 = 2
!3 = 3 x 2 x 1 = 6
!4 = 4 x 3 x 2 x 1 = 24
long factorielle(int n)
{
long r = 1;
while (n-- > 0)
r *= n;
return r;
}
Exercice 2
[modifier | modifier le wikicode]Créez une autre fonction factorielle
mais récursive cette fois.
Une fonction récursive est une fonction qui s'appelle elle-même.
!n = n x !(n - 1)
long factorielle(long n)
{
if (n == 1) return 1;
return n*factorielle(n - 1);
}
Exercice 3
[modifier | modifier le wikicode]Donner la déclaration d'un pointeur fct
sur la dernière fonction factorielle
.
long (*fct)(long);
Exercice 4
[modifier | modifier le wikicode]En C++, les systèmes callback
sont des systèmes qui enregistrent des fonctions, afin de les exécuter en cas d'évènement (comme par exemple si on touche le clavier).
Albert n'est pas fort en maths. Il veut un système pour faire des racines carrées, des carrés, des cosinus et des factorielles. Il utilise l'environnement callback situé dans l'annexe 1. Cet environnement crée une structure f_maths, qui enregistre une fonction et son symbole mathématique. Pour utiliser sa calculatrice, il doit enregistrer correctement les fonctions dans le gestionnaire. Ensuite, le programme interroge l'utilisateur pour entrer le symbole de son opération. Puis, l'utilisateur entre sa valeur et le programme effectue l'opération. Compléter le programme en annexe avec la fonction main() uniquement.
#include <cmaths>
#include <stdio.h>
typedef double (*fct)(double);
int nb_fct;
struct f_maths { fct fonction; char symb; };
f_maths gestionnaire[10];
void initialiser(){ nb_fct = 0; }
double carré(double a) { return a * a; }
double factorielle(double n)
{
if (n == 1) return 1;
return n*factorielle(n - 1);
}
void enregistrer(fct f, char sy)
{
struct s;
s.fonction = f;
s.symb = sy;
gestionnaire[nb_fct++] = s;
}
void executer()
{
char sy;
double val;
printf("Entrer le symbole:\n");
scanf("%c", &sy);
printf("Entrer la valeur:\n");
scanf("%g", &val);
for(int i = 0; i < nb_fct; i++)
if (gestionnaire[i].symb == sy)
{
printf("Le résultat est %g.\n", (*gestionnaire[i].fonction)(val);
return;
}
printf("Aucune fonction trouvée.\n");
}
Pour faire des cosinus et des racines carrées, cmaths contient les fonctions cos()
et sqrt()
.