C++ Les fonctions

Présentation Utilité : Dès qu'un programme dépasse la centaine de lignes de code, il est pratique de pouvoir le décomposer en plusieurs parties dont on pourra comprendre leur rôle (sans avoir à en examiner le code). Les fonctions permettent ce découpage. Définition : Une fonction est un bloc d'instructions qui peut être utilisé à loisirs dans votre programme. Rôle : Une fonction peut jouer les rôles suivants ● Fournir un résultat (ex : la fonction pow) ● Modifier les valeurs de certains paramètres ● Réaliser une action (afficher une phrase à l'écran)

Déclaration et définition #include using namespace std; float multipliePuisAdditionne(float a, float b, int c); // Déclaration de la fonction multipliePuisAdditionne (fonction globale au fichier) int main( ) { float a=0, b=0, c=1.0, d=2.5; // Variables locales à la fonction main int z=2, y=3; // Variables locales à la fonction main a = multipliePuisAdditionne(c, d, z); // Appel OK car la fonction a été déclarée avant cout << "valeur de a = " << a << endl; b = multipliePuisAdditionne(5, d, y); // Appel OK car la fonction a été déclarée avant cout << "valeur de b = " << b << endl; } float multipliePuisAdditionne(float a, float b, int c) { // Définition de la fonction multipliePuisAdditionne float resultat = 0; // Variable locale à la fonction multipliePuisAdditionne resultat = ((a*b)+c); return resultat; } (1) (2) (3) (4) (5) (6) (7) (8) (9) (10) (11)

Arguments/Paramètres Les arguments figurant dans la déclaration ou la définition de la fonction sont appelés : arguments formels ou paramètres formels. float multipliePuisAdditionne(float a, float b, int c); Lors de la déclaration ou de la définition de la fonction multipliePuisAdditionne, a, b et c sont des paramètres formels. Leur nom n'a aucun importance. Vous pouvez même ne pas le préciser lors de la déclaration. Ex : float multipliePuisAdditionne(float, float, int); **************************************************************************************************************** ** Ceux figurant lors de l'appel à une fonction sont appelés arguments effectifs ou paramètres effectifs. multipliePuisAdditionne(c, d, z); multipliePuisAdditionne(5, d, y); c, d, z, 5 et y sont des paramètres effectifs.

L'instruction return ● L'instruction return peut mentionner n'importe quelle expression. Ex : float multipliePuisAdditionne(float a, float b, int c) { return ((a*b)+c); } ● L'instruction return peut apparaître plusieurs fois à l'intérieur d'une fonction. Ex : float divisonParZero(float a, float b) { if(b != 0) { return a/b; } else { return 0; } cout << ''Fin de la fonction'' << endl; // Cette instruction ne sera jamais exécutée ! Pourquoi ? }

Fonctions sans valeur de retour ou sans arguments Une fonction ne retournant aucun résultat doit avoir comme type de retour le mot-clé void. Ex : void afficher(int); // Fonction ne retournant aucun résultat. Naturellement, cette fonction n'aura aucun return dans son corps. Par conséquent, il est interdit d'écrire float a; a = afficher(5); Une fonction ne prenant aucun argument s'écrit de la façon suivante : float tirage( ); // Fonction ne prenant aucun argument mais retournant un float. Par conséquent, il est faux d'écrire tirage(41); // Appel à la fonction tirage avec le paramètre 41 → Erreur de compilation

#include using namespace std; void afficheCarre(int, int); // Déclaration de la fonction afficheCarre void erreur(); // Déclaration de la fonction erreur int main( ) { int debut, fin; cout << "Entrer un nombre de début (inférieur ou égal à 10) : "; cin >> debut; cout << "Entrer un nombre de fin (supérieur ou égal à 20) : "; cin >> fin; if(debut > 10 || fin < 20) { erreur(); } else { afficheCarre(debut, fin); } void afficheCarre(int d, int f) { // Définition de la fonction afficheCarre int i; for(i=d; i<=f; i++) { cout << i << " a pour carré " << i*i << endl; } void erreur() { cout << "Vous avez fait une erreur de saisie." << endl; }

Transmission des arguments par valeur #include using namespace std; void echange(int x, int y); // Déclaration de la fonction echange int main( ) { int n=10, p=20; cout << "Avant appel : " << n << ", " << p <<endl; echange(n,p); cout << "Après appel : " << n << ", " << p <<endl; } void echange(int a, int b) { int c; cout << "Début echange : " << a << ", " << b <<endl; c=a; a=b; b=c; cout << "Fin echange : " << a << ", " << b <<endl; }

Résultat Avant appel : 10, 20 Début echange : 10, 20 Fin echange : 20, 10 Après appel : 10, 20 La fonction echange n'échange pas les valeurs de nos arguments !!!

Transmission des arguments par valeur Quand on appelle une fonction, les valeurs des paramètres effectifs sont recopiées dans les paramètres formels. int main( ) { int n=10, p=20; cout << "Avant appel : " << n << ", " << p <<endl; echange(n,p); // n et p sont les paramètres effectifs cout << "Après appel : " << n << ", " << p <<endl; } void echange(int a, int b) { // a va prendre la valeur de n soit 10 et b va prendre la valeur de p soit 20 int c; cout << "Début echange : " << a << ", " << b <<endl; c=a; // c vaut 10 a=b; // a vaut 20 b=c; // b vaut 10 cout << "Fin echange : " << a << ", " << b <<endl; } La fonction echange a bien échangé les valeurs de a et b. Mais à aucun moment n et p n'ont changé de valeur !

Explications int main( ) { int n=10, p=20; cout << "Avant appel : " << n << ", " << p <<endl; echange(n,p); cout << "Après appel : " << n << ", " << p <<endl; return 0; } void echange(int a, int b) { int c; cout << "Début echange : " << a << ", " << b <<endl; c=a; a=b; b=c; cout << "Fin echange : " << a << ", " << b <<endl; } a b 10 n 20 p c

Transmission par référence #include using namespace std; void echange(int &x, int &y); // Déclaration de la fonction echange int main( ) { int n=10, p=20; cout << "Avant appel : " << n << ", " << p <<endl; echange(n,p); cout << "Après appel : " << n << ", " << p <<endl; } void echange(int &a, int &b) { int c; cout << "Début echange : " << a << ", " << b <<endl; c=a; a=b; b=c; cout << "Fin echange : " << a << ", " << b <<endl; }

Résultat Avant appel : 10, 20 Début echange : 10, 20 Fin echange : 20, 10 Après appel : 20, 10 En passant par référence, la fonction modifie les valeurs des paramètres effectifs !

Explications int main( ) { int n=10, p=20; cout << "Avant appel : " << n << ", " << p <<endl; echange(n,p); cout << "Après appel : " << n << ", " << p <<endl; } void echange(int &a, int &b) { int c; cout << "Début echange : " << a << ", " << b <<endl; c=a; a=b; b=c; cout << "Fin echange : " << a << ", " << b <<endl; } a b 10 n 20 p c

Les variables ● Variables globales : variables déclarées en dehors de toutes fonctions. Leur portée s'étend à tout le fichier à partir de leur déclaration. ● Leur durée de vie est la durée de vie du programme. Ex : #include using namespace std; int variableGlobale1; // Variable déclarée en début de fichier donc accessible par toutes les fonctions int main( ) { variableGlobale1 = 0; // Bon variableGlobale2 = 5; // Ne marche pas } int variableGlobale2; // Variable accessible seulement par la fonction fonction1 void fonction1() { variableGlobale1 = 10; // Bon variableGlobale2 = 15; // Bon }

Les variables ● Variables locales : variables déclarées à l'intérieur d'un bloc (fonction, boucle, condition, etc). Leur portée s'étend à tout le bloc à partir de leur déclaration. ● Elles n'ont aucun lien avec les variables globales, c'est pourquoi une variable locale peut avoir le même nom qu'une variable globale. ● Elles ont une durée de vie égal à la durée de vie du bloc dans lequel elles sont déclarées. A retenir : Une variable locale à une fonction se voit allouer un espace en mémoire au moment de l'exécution de la fonction. Cet endroit s'appelle la pile. Une fois la fonction terminée, cet espace en mémoire ne lui est plus réservé.

Votre programme en mémoire Variables globales initialisées Variables globales non-initialisées Votre code Variables locales (Cet espace évolue) Variables dynamiques (Cet espace évolue)

Explications int main( ) { int n=10, p=20; cout << "Avant appel : " << n << ", " << p <<endl; echange(n,p); cout << "Après appel : " << n << ", " << p <<endl; } void echange(int &a, int &b) { int c; cout << "Début echange : " << a << ", " << b <<endl; c=a; a=b; b=c; cout << "Fin echange : " << a << ", " << b <<endl; } a b 10 n 20 p c

Les variables Il est possible de demander d'attribuer un emplacement permanent à une variable locale. Cela dans le but de conserver sa valeur d'un appel au suivant. Il faut pour cela faire appel au mot-clé static. Ex : #include using namespace std; void fct(); int main( ) { int n; for(n=1; n<=5; n++) { fct(); } void fct() { static int i=5; i++; cout << "Appel numéro " << i << endl; }

Résultat Appel numéro 6 Appel numéro 7 Appel numéro 8 Appel numéro 9 Appel numéro 10

Explications int main( ) { int n=10, p=20; cout << "Avant appel : " << n << ", " << p <<endl; echange(n,p); cout << "Après appel : " << n << ", " << p <<endl; } void echange(int &a, int &b) { static int c; cout << "Début echange : " << a << ", " << b <<endl; c=a; a=b; b=c; cout << "Fin echange : " << a << ", " << b <<endl; } a b 10 n 20 p c static int c;

Paramètres par défaut En C++ (contrairement au C), il est possible d'appeler une fonction sans passer tous les paramètres. Ceci à la condition qu'une valeur par défaut ait été attribuée au paramètre manquant. Ex : #include using namespace std; void fct(int, int=12); int main( ) { int n=10, p=20; fct(n, p); fct(n); } void fct(int a, int b) { cout << "Premier paramètre : " << a << endl; cout << "Deuxième paramètre : " << b << endl; }

Résultat Premier paramètre : 10 Deuxième paramètre : 20 Premier paramètre : 10 Deuxième paramètre : 12 A noter que l'appel fct() n'aurait pas fonctionné car le premier paramètre n'a pas de valeur par défaut définie.

Paramètres par défaut Lorsqu'une déclaration prévoit des valeurs par défaut, les paramètres concernés doivent obligatoirement être les derniers de la liste. Ex : La déclaration float fct(int = 5, long, int = 3) est interdite. En effet, sinon comment interpréter l'appel suivant : fct(10,20);

C++ Fin des fonctions