Programmation C++ (débutant)/Les fonctions

Ecrire une fonction

Syntaxe : type identificateur(paramètres) { Corps de la fonction }
A chaque appel de la fonction on exécute le corps de la fonction.
L’identificateur est le nom de la fonction.
La fonction peut avoir des paramètres.
La fonction peut renvoyer une valeur de type type.

Appel à une fonction

Lors de l’appel de la fonction, le programme exécute la totalité des instructions du corps de la fonction, puis reprend le programme juste après l’appel de la fonction.
Exemple 1 : un exemple de fonction
#include <iostream>
using namespace std;
void b()
{
cout<<« Bonjour »<<endl;
}
int main()
{
cout<<« COUCOU1″<<endl;
b();
cout<<« COUCOU2″<<endl;
b();
b();
cout<<« COUCOU3″<<endl;
b();
return 0;
}
• Explications
• Dans ce programme, on a créé une fonction b qui se contente d’afficher « Bonjour » à l’écran. La fonction b est précédée du type void : cela signifie que la fonction ne renvoie aucune valeur au programme appelant.
• Le programme principal (la fonction main()) affiche « COUCOU1 » à l’écran, ensuite appelle la fonction b, affiche le message « COUCOU2 » à l’écran, appelle ensuite 2 fois la fonction b, affiche le message « COUCOU3 » et appelle une dernière fois la fonction b.
• Exécution de l’exemple 1
Lorsqu’on exécute le programme voici ce qu’on obtient à l’écran :
COUCOU1
Bonjour
COUCOU2
Bonjour
Bonjour
COUCOU3
Bonjour

Les paramètres

On peut paramétrer une fonction : les paramètres permettent de rendre la fonction plus générale donc plus facilement réutilisable. La réutilisation de code est une des notions fondamentales du langage C++. La notion de fonction est une des premières méthodes nous permettant d’aborder le sujet.
Exemple 2 : une fonction avec des paramètres
#include <iostream>
using namespace std;
void b(int i)
{
int j;
for(j=0; j<i; j++) cout<<« Bonjour »<<endl;
}
int main()
{
cout<<« COUCOU1″<<endl;
b(2);
cout<<« COUCOU2″<<endl;
b(3);
return 0;
}
• Explications
• Cette fois-ci la fonction b comporte un paramètre entier i. Cette fonction affiche i fois « Bonjour » à l’écran.
• Dans le programme principal, la fonction main() affiche « COUCOU1 », appelle ensuite la fonction b avec comme paramètre 2, **Lors de l’appel b(2) de la fonction, on recopie la valeur 2 dans i puis on exécute le corps de la fonction avec cette valeur de i : on affiche donc 2 fois « Bonjour ».
• Lors de l’appel b(3) de la fonction, on recopie la valeur 3 dans i puis on exécute le corps de la fonction avec cette valeur de i : on affiche donc 3 fois « Bonjour ».
• Exécution
Lorsqu’on exécute le programme voici ce qu’on obtient à l’écran :
COUCOU1
Bonjour
Bonjour
COUCOU2
Bonjour
Bonjour
Bonjour

Environnement d’une fonction

• Une fonction peut avoir ses propres variables locales.
• On appelle environnement d’une fonction l’ensemble des variables accessibles dans le corps de la fonction.
• Il est possible de définir des variables globales (voir la définition des constantes) : il est fortement déconseillé d’utiliser des variables globales autres que des constantes.
• L’environnement d’une fonction comprend :
• les variables locales à la fonction.
• les paramètres de la fonction.
• les variables globales.
Une fonction qui renvoie une valeur
Une fonction peut renvoyer une valeur d’un certain type à l’environnement appelant.
void signifie que la fonction ne renvoie rien. Si on veut que la fonction renvoie une certaine valeur, il faudra écrire un autre type à la place de void.
Le mot clé return permet :
• d’arrêter l’exécution de la fonction (il est en général placé à la fin de la fonction)
• de renvoyer une valeur à l’environnement appelant.
Si une fonction b renvoie un entier, l’appel s’écrira : a=b(…); a permettra de récupérer la valeur renvoyée par le return.
Exemple 3 : une fonction qui renvoie une valeur
#include<iostream>
using namespace std;
int b(int i, int j)
{
int k;
k = i*i + j*j;
return k;
}
int main()
{
int a;
a = b(3,4);
cout<<« Le resultat vaut : « <<a<<endl;
return 0;
}
• Explications
Lors de l’appel a=b(3,4);
• 3 et 4 sont respectivement recopiés dans les variables i et j.
• On exécute le corps de la fonction (qui contient une variable locale k)
• return k permet d’arrêter l’exécution de la fonction en renvoyant la valeur de k qui est recopiée dans a.
• L’environnement de la fonction main ne comprend que la variable a : on ne peut pas utiliser les variables i, j et k dans la fonction main.
• L’environnement de la fonction b comprend les variables i,j et k : on ne peut pas utiliser a dans la fonction b.
• La séparation des environnements permet de mieux structurer les applications.
• Exécution :
Lorsqu’on exécute le programme voici ce qu’on obtient à l’écran :
Le resultat vaut : 25
Exemple 4 : une autre fonction
#include <iostream>
using namespace std;
int b(int i)
{
int k, s=0;
for(k=1; k<=i; k++) s = s+k*k;
return s;
}
int main()
{
int a;
a = b(4);
cout<<« Le résultat vaut : »<<a<<endl;
return 0;
}
• Explications
• On définit une fonction b qui a un paramètre entier i et qui calcule la somme des carrés des i premiers entiers.
• Dans la fonction main, on appelle b(4) et on récupère la valeur renvoye dans la variable a. a contient donc la somme des 4 premiers carrés.
• Exécution
Lorsqu’on exécute le programme voici ce qu’on obtient à l’écran :
Le résultat vaut : 30
Exemple 5 : une fonction manipulant des réels
#include<iostream>
using namespace std;
double b(double x, double y)
{
double m;
m = (x+y) / 2;
return m;
}
int main()
{
double a;
a = b(3.2, 4.2);
cout<<« Le résultat vaut : »<<a<<endl;
return 0;
}
• Explications :
• Dans cette exemple, la fonction b a 2 paramètres de type double, nommées x et y. La fonction b renvoie un double. Cette fonction renvoie la moyenne de x et de y. La variable m est une variable locale à la fonction b.
• Dans le programme principal, on récupère dans a la moyenne de 3.2 et 4.2 en appelant la fonction b.
• Exécution :
Lorsqu’on exécute le programme voici ce qu’on obtient à l’écran :
Le résultat vaut : 3.7

Compatibilité des types

Une fonction peut avoir des paramètres de différents types. Lors de l’appel, il convient de respecter l’ordre et le type des paramètres entre l’entête et le corps de la fonction.

Passage de tableaux en paramètres

Lorsqu’on passe un tableau (d’entiers par exemple en paramètre), il y a identification entre le tableau de l’environnement appelant et le paramètre de la fonction. Toute modification du tableau dans la fonction est répercutée dans le tableau de l’environnement appelant.