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.

Slides:



Advertisements
Présentations similaires
Les fonctions A quoi ça sert ?
Advertisements

Formation universitaire à .NET: Introduction à C#
M. BENJELLOUN : Info II Mohammed BENJELLOUN Service dInformatique Faculté Polytechnique de Mons
FONCTIONS avec paramètres en Entrée/Sortie
Faculté Polytechnique de Mons
La notion de type revisitée en POO
HistoriqueHistorique Langage C++, parution du livre Bjarne Stroustrup Normalisation ANSI.
Classe 1 CSI2572 Autres modificateurs de déclaration de variables: & volatile & register & static & auto & extern & const volatile Indique au compilateur.
Ecrire 10 fois "Bonjour" sur 10 lignes différentes
M. BENJELLOUN : 2005 Le but final est de programmer un jeu où l'ordinateur choisira un nombre aléatoire entre 0 et 100 que vous devez deviner.
Le débogage Semaine 12 Version A15. Plan de leçon - Débogage  Commentaire javadoc  Définition  Fonctionnement  Point d’arrêt  Exécution  Contrôler.
Outils logiciel pour la programmation en C. 2 Automatiser la compilation : make make est un utilitaire présent dans toute les distribution de linux >
CINI – Li115 1 Semaine 9 Algorithmes de tri ● Introduction ● Tri à bulle ● - principe ● - algorithme ● - efficacité ● Tri par sélection ● - principe, algorithme,
IFT359 – Programmation fonctionnelle Thème 02 B partie A introduction au langage fonctionnel choisi 1.
Tableaux et Pointeurs Chaînes de Caractères Programmation Impérative II.
CINI – Li115 1 Semaine 3 Boucles (suite), tirages aléatoires, bibliothèque graphique ● Imbrication d'instructions if et for ● Boucles for imbriquées ●
CINI – Li115 1 Semaine 4 Révisions ● Questions de cours ● Types des expressions ● Déclaration de variables ● Instruction conditionnelle et boucles ● Structure.
CINI – Li115 1 Semaine 6 Les fonctions ● Pourquoi écrire des fonctions ? ● Définition de fonctions ● Fonction main ● Appels de fonctions ● Portée des variables.
CINI – Li115 1 Semaine 10 Les pointeurs ● Notion d'adresse ● Déclaration et utilisation de pointeurs ● "Types pointeur" et initialisation des pointeurs.
1 Programmation en C++ Fonctions ● Déclaration et définition de fonctions ● Arguments ● Surcharge ● Arguments optionnels ● Fonctions constantes ● Fonctions.
1 Programmation en C++ C++ de base ● Programme C++ ● Variables, objets, types ● Fonctions ● Namespace ● Tests ● Boucles ● Pointeurs, références.
1 Programmation en C++ C++ de base ● Programme C++ ● Variables, objets, types ● Types et opérations fondamentales ● Tests ● Boucles ● Pointeurs, références.
CINI – Li115 1 Semaine 11 Les pointeurs (suite) ● Tableaux et pointeurs ● Questions sur les pointeurs.
Semaine 8 Retour sur les tableaux : fonctions et récursivité
Les Instructions Itératives (Les Boucles)
Cours de programmation en langage C (Norme ANSI)
Pas de variable globale
Les notions de classe et d'objet
JavaScript.
Algorithmique et programmation de modèles numériques
Semaine #1 INF130 par Frédérick Henri.
Javadoc et débogueur Semaine 03 Version A17.
AO (Architecture des ordinateurs)
Principes de programmation (suite)
Algorithmique Langage C
11ième Classe (Mardi, 18 novembre) CSI2572
Semaine 11 Les pointeurs (suite)
Les fonctions.
Les fonctions.
Algorithmiques Abdelbasset KABOU
Matrices, déclaration en CSharp
Programmation en C++ Fonctions
Alternative : syntaxe CSharp
SIF-1053 Architecture de ordinateurs
Un Algorithme , c'est Quoi ?
Principes de programmation (suite)
Langages de programmation TP3
Algorithmique & Langage C
Les interfaces en PHP.
Semaine #4 INF130 par Frédérick Henri.
6. Les types utilisateurs et les structures de données
L E C ORPS D ’ UN A LGORITHME / P ROGRAMME – L A PARTIE I NSTRUCTION Réalisé par : OUZEGGANE Redouane Département de Technologie Faculté de Technologie.
L’I NSTRUCTION DE T EST A LTERNATIF Réalisé par : OUZEGGANE Redouane Département de Technologie Faculté de Technologie – Université A.Mira, Bejaia Année.
L ES I NSTRUCTIONS I TÉRATIVES (L ES B OUCLES ) Réalisé par : OUZEGGANE Redouane Département de Technologie Faculté de Technologie – Université A.Mira,
Les flux en C++ Les flux d’entrées sorties Les flux standards.
Programmation en C++ Fonctions
Cours 8 5. Appels de fonctions Le matériel Concepts de pile
Programmation en C++ C++ de base
1 RECURSIVITE PRESENTATION Ch. PAUL ALGORITHMIQUE Présentation de la récursivité.
Entrées/Sorties - Variables - Calculs - Alternative
Eléments de base du langage C
Les classes et les objets
Semaine #3 INF130 par Frédérick Henri.
Les exceptions Le mécanisme des exceptions est destiné à permettre aux fonctions profondes d'une bibliothèque de notifier la survenue d'une erreur aux.
Définition : 2 Les structures de contrôle conditionnelles permettent à un programme de modifier son traitement en fonction d’une condition.
Dépiler et mettre valeur dans RT (récup. paramètre)
Principes de programmation (suite)
Cours 8 5. Appels de fonctions Le matériel Concepts de pile
Fonctions Abstractions procédurales.
Eléments de base du langage C
Transcription de la présentation:

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