SlideShare una empresa de Scribd logo
1 de 30
Descargar para leer sin conexión
Programmation Orientée Objet en C++
          4ème Partie: Fonctions



              Fabio Hernandez
            Fabio.Hernandez@in2p3.fr
Vue d'Ensemble
   Notions de base
   Types, variables, opérateurs
   Contrôle d'exécution
   Fonctions
   Mémoire dynamique
   Qualité du logiciel
   Evolution du modèle objet
   Objets et classes
   Fonctions membres
   Classes génériques
   Héritage
   Polymorphisme
   Héritage multiple
   Entrée/sortie


POO en C++: Fonctions             108        © 1997-2003 Fabio HERNANDEZ
Table des Matières

   Déclaration de la Fonction
   Utilisation de la Fonction
   Prototype de Fonction
   Contrôle de Type
   Valeur de Retour
   Signature de Fonction
   Passage des Arguments
   Tableau comme Argument
   Fonctions Inline
   Portée des Variables
   Durée de Vie des Variables

POO en C++: Fonctions           109          © 1997-2003 Fabio HERNANDEZ
Déclaration de la Fonction

   Une fonction est une opération définie par le programmeur
   Les opérandes sont les paramètres de la fonction
   Exemple
          type de la           nom de la
          valeur de            fonction         liste des
          retour                               paramètres


                          int min(int a, int b)
                          {                                corps de
                                                           la fonction
                             return (a < b) ? a : b;
                          }



POO en C++: Fonctions                 110              © 1997-2003 Fabio HERNANDEZ
Utilisation de la Fonction

   Toute fonction doit être déclarée avant son utilisation
   #include <iostream> // C++ standard I/O declarations
   extern int min(int a, int b);
   int main()
   {
      int value1;
      int value2;
      cout << "Enter two integers: " << endl;
      cin >> value1 >> value2;
      cout << "The minimun between: " << value1
           << " and " << value2 << " is "
           << min(value1, value2) << endl;
      return 0;
   }


POO en C++: Fonctions               111          © 1997-2003 Fabio HERNANDEZ
Prototype de Fonction

   Une fonction ne peut être définie qu'une seule fois dans un
   programme
   Mais peut être utilisée autant de fois que nécessaire
   Généralement, elle est définie dans un fichier .cpp avec
   d'autres fonctions et utilisée dans des modules différents
   Le moyen de déclarer une fonction est le prototype
                        extern int min(int a, int b);

   L'objectif du prototype est d'informer le compilateur du
   type de la valeur de retour, du nombre de paramètres et du
   type de chacun


POO en C++: Fonctions                   112             © 1997-2003 Fabio HERNANDEZ
Prototype de Fonction (suite)
   Associé à chaque module (fichier .cpp) il faut créer un fichier avec les
   prototypes des fonctions définies dans celui-ci
   Ce fichier de prototypes sera inclus via une instruction pré-processeur
   dans tous les autres modules qui utilisent une ou plusieurs de ces
   fonctions
   Exemple: supposons que dans le fichier util.cpp se trouvent les
   définitions des fonctions min et abs suivantes
           int min(int a, int b)
           {
              return (a < b) ? a : b;
           }
           int abs(int a)
           {
              return (a < 0) ? -a : a;
           }



POO en C++: Fonctions                   113               © 1997-2003 Fabio HERNANDEZ
Prototype de Fonction (suite)

   Nous créons le fichier util.prt (le nom n'a pas d'importance
   pour le compilateur mais en a pour le programmeur) avec les
   déclarations suivantes
           extern int min(int a, int b);
           extern int abs(int a);
   Ce fichier peut maintenant être inclus dans tout module (fichier
   .cpp) nécessitant une des fonctions définies dans util.cpp
           #include <iostream>
           #include "util.prt"
           int main()
           {
              cout << "The absolute value of -345 is: "
                   << abs(-345) << endl;
              return 0;
           }

POO en C++: Fonctions                114         © 1997-2003 Fabio HERNANDEZ
Contrôle de Type

   C++ est un langage fortement typé
   Le type de la valeur de retour et de chacun des arguments
   d'une fonction sont contrôlés en compilation
   S'il y a des différences entre le type de la déclaration et le
   type des arguments utilisés dans l'invocation de la fonction
         une conversion implicite est effectuée si possible (probablement avec
         warning)
           int i = min(234, 78.90); // conversion a int 78

         autrement, une erreur est détectée et la compilation échoue
            int i = min(234, "a string"); // ERROR


   Le nombre d'arguments est aussi contrôlé
POO en C++: Fonctions                  115                 © 1997-2003 Fabio HERNANDEZ
Valeur de Retour
   Peut être d'un type fondamental (int, long,...), d'un type dérivé (int*)
   ou d' un type défini par le programmeur
           enum Color {Black, White};
           Color getComplementaryColor(Color currentColor)
           {
              return (currentColor == Black) ? White : Black;
           }
   Le type void est utilisé pour signifier l'absence de valeur de retour
           void printError(const char* message)
           {
              cerr << "ERROR: " << message << endl;
           }
   L'instruction return n'est pas strictement nécessaire pour une fonction
   qui retourne void




POO en C++: Fonctions                 116                 © 1997-2003 Fabio HERNANDEZ
Signature de Fonction

   La liste des arguments de la fonction est connue comme la
   signature de la fonction
   Le nom et la signature de la fonction identifient pleinement
   chaque fonction
   Exemple:
           float min(float a, float b)
           {
              return (a < b) ? a : b;
           }
   est différente de la fonction min vue précédemment




POO en C++: Fonctions             117            © 1997-2003 Fabio HERNANDEZ
Signature de Fonction (suite)

   Lors de l'invocation de la fonction, le compilateur choisit entre
   les différentes possibilités, selon le type des arguments
           extern float min(float a, float b);
           extern int min(int a, int b);
           void main()
           {
              const float f1 = 0.234;
              const float f2 = 34.90;
              const int i1 = 190;
              int intMin = min(i1, 250);
                           // min(int, int) is called
              float floatMin = min(f1, f2);
                           // min(float, float) is called
           }

POO en C++: Fonctions                118          © 1997-2003 Fabio HERNANDEZ
Signature de Fonction (suite)

   Le type de la valeur de retour ne fait pas partie de la
   signature
           int min(short a, short b);
           short min(short a, short b);
                               // ERROR: same name and signature




POO en C++: Fonctions                119          © 1997-2003 Fabio HERNANDEZ
Passage des Arguments

   Les arguments des fonctions en C++ sont passés par valeur
   Une copie de la valeur de chaque argument est copiée dans la
   pile d'exécution de la fonction
   Les modifications faites à ces valeurs affectent uniquement
   les copies et ne sont pas reflétées dans les arguments actuels
   Exemple: soit la fonction

           void increment(int value)
           {
              value += 1;
           }




POO en C++: Fonctions             120            © 1997-2003 Fabio HERNANDEZ
Passage des Arguments (suite)
           extern increment(int i);
           void main()
           {
              int counter=100;
              cout << "Before increment, counter is = "
                   << counter << endl;
              increment(counter);
              cout << "After increment, counter is = "
                   << counter << endl;
           }
   produit
           Before increment, counter is = 100
           After increment, counter is = 100



POO en C++: Fonctions             121            © 1997-2003 Fabio HERNANDEZ
Passage des Arguments (suite)

   Le passage des arguments par valeur n'est pas toujours
   souhaitable
         quand la fonction doit changer la valeur des arguments
         quand l'argument de la fonction est un objet de grande taille: le coût
         en temps et en mémoire de la copie serait très élevé
   Deux façons de passer les arguments par référence
         utilisation des pointeurs
                   void increment(int* value)
                   {
                      *value += 1;
                   }

         à l'invocation, l'argument de la fonction est l'adresse de l'objet et
         pas l'objet lui même


POO en C++: Fonctions                   122                  © 1997-2003 Fabio HERNANDEZ
Passage des Arguments (suite)
           extern increment(int* value);
           void main()
           {
              int counter=100;
              cout << "Before increment, counter is = "
                   << counter << endl;
              increment(&counter); // pass the address of count
              cout << "After increment, counter is = "
                   << counter << endl;
           }
   produit
           Before increment, counter is = 100
           After increment, counter is = 101



POO en C++: Fonctions             123            © 1997-2003 Fabio HERNANDEZ
Passage des Arguments (suite)

   Deux façons de passer les arguments par référence (suite)
         utilisation des références
            void increment(int& value)
            {
                 value += 1;
            }
            void main()
            {
                  int counter=100;
                  cout << "Before increment, counter is = "
                        << counter << endl;
                  increment(counter);
                  cout << "After increment, counter is = "
                        << counter << endl;
             }
   produit
           Before increment, counter is = 100
           After increment, counter is = 101
POO en C++: Fonctions             124              © 1997-2003 Fabio HERNANDEZ
Tableau comme Argument

   Les tableaux en C++ ne sont jamais passés par valeur
   Un tableau est passé comme un pointeur à son premier
   élément (celui de la position zéro)
   Conséquences:
         tout changement fait à un tableau à l'intérieur d'une fonction est
         effectué au tableau lui même et pas à une copie
         la taille du tableau (le nombre de positions) ne fait pas partie du type:
         la fonction ne connaît donc pas cette taille




POO en C++: Fonctions                    125                  © 1997-2003 Fabio HERNANDEZ
Tableau comme Argument (suite)

   Exemple
           void printArray(int* array, int howmany)
           {
              cout << "[";
              for (int pos=0; pos < howmany; pos++)   La taille du tableau
                 cout << " " << array[pos];               est aussi un
              cout << " ]" << endl;                        paramètre
           }

           void incrementArray(int* array, int howmany)
           {
              for (int pos=0; pos < howmany; pos++)
                 array[pos] += 100;
           }



POO en C++: Fonctions             126            © 1997-2003 Fabio HERNANDEZ
Tableau comme Argument (suite)

   Exemple (suite)
           void main()
           {
              const int MaxItems = 5;
              int itemTable[MaxItems]={5, 10, 15, 20, 25};
                cout << "Originally, itemTable is: ";
                printArray(itemTable, MaxItems);
                incrementArray(itemTable, MaxItems);
                cout << "After increment, itemTable is: ";
                printArray(itemTable, MaxItems);
           }
   produit
          Originally, itemTable is: [ 5 10 15 20 25 ]
          After increment, itemTable is: [ 105 110 115 120 125 ]


POO en C++: Fonctions               127            © 1997-2003 Fabio HERNANDEZ
Tableau comme Argument (suite)

   Exemple (suite)
         La fonction printArray ne modifie pas le tableau passé en argument
         On devrait donc la définir de la façon suivante

           void printArray(const int* array, int howmany)
           {
              cout << "[";
              for (int pos=0; pos < howmany; pos++)
                 cout << " " << array[pos];
              cout << " ]" << endl;
           }




POO en C++: Fonctions                 128                © 1997-2003 Fabio HERNANDEZ
Fonctions Inline

   Parfois le temps d'exécution d'une fonction est petit
   comparé au temps nécessaire pour appeler la fonction
   Le mot clé inline informe le compilateur qu'un appel à cette
   fonction peut être remplacé par le corps de la fonction
   Exemple
           inline int max(int a, int b)
           {
              return (a < b) ? b : a;
           }

           void main()
           {
              int m = max(134, 876);
           }


POO en C++: Fonctions             129          © 1997-2003 Fabio HERNANDEZ
Fonctions Inline (suite)

   Le compilateur génère le code équivalent à l'expansion de la
   fonction, comme si l'on avait écrit

           void main()
           {
              int m = (134 < 876) ? 876 : 134;
           }
   Conséquences:
         programme plus rapide
         programme plus gros
   Les fonctions inline doivent être définies dans des fichiers
   d'entête (.h) qui seront inclus dans des fichiers source
   (.cpp), pour que le compilateur puisse faire l'expansion


POO en C++: Fonctions             130            © 1997-2003 Fabio HERNANDEZ
Portée des Variables

   Une définition de variable introduit un identificateur
   Il ne peut être utilisé que dans une partie du source du
   programme (portée)
   Une variable définie à l'intérieur d'une fonction (variable
   locale) peut être utilisée à partir de sa définition jusqu'à la
   fin du bloc où la définition apparaît
           void swap(int& a, int& b)
           {
              int temp = a;   // temp is a local variable
              a = b;
              b = temp;
           }



POO en C++: Fonctions             131              © 1997-2003 Fabio HERNANDEZ
Portée des Variables (suite)

   Une variable définie en dehors d'une fonction ou d'une classe,
   (variable globale), est visible à partir de sa définition jusqu'à
   la fin du fichier source (.cpp) où sa définition apparaît
   Une variable peut être définie dans un bloc avec le même nom
   qu'un identificateur déjà existant: dans ce cas, cette variable
   cache la variable du bloc externe ou la variable globale qui
   porte le même nom




POO en C++: Fonctions               132            © 1997-2003 Fabio HERNANDEZ
Portée des Variables (suite)

   Exemple
           int count;                     // global variable

           void dummy()
           {
              int count;                  // local count, hides global
              count = 100;                // modifies local count
              while (count > 0) {
                 // do something
                 --count;
              }
           }

           void increment()
           {
              count += 1;   // modifies global count
           }

POO en C++: Fonctions               133              © 1997-2003 Fabio HERNANDEZ
Durée de Vie des Variables

   Lors de l'exécution du programme, chaque objet est créé
   quand sa définition apparaît et est détruit quand son
   identificateur sort de contexte
   En particulier, les variables locales sont créées (allocation de
   mémoire dans la pile d'exécution) au moment de l'invocation
   (activation) de la fonction
   Elles disparaissent quand la fonction finit son exécution
   Les variables(objets) globales sont créées et initialisées une
   seule fois et existent jusqu'à la fin de l'exécution du
   programme



POO en C++: Fonctions               134            © 1997-2003 Fabio HERNANDEZ
Durée de Vie des Variables (suite)

   A l'aide du mot clé static le programmeur peut définir une
   variable locale de façon à ce qu'elle existe jusqu'à la fin du
   programme
   Ce type des variables sont initialisées une seule fois
   Exemple
           void dummy()
           {
              static int count=1;       // created and initialized
                                        // only once
                int local=100;          // created and initialized
                                        // at each call
                cout << " local = " << local <<
                     << " count = " << count << endl;
                ++count;
           }

POO en C++: Fonctions               135            © 1997-2003 Fabio HERNANDEZ
Durée de Vie des Variables (suite)

   Exemple (suite)

           void main()
           {
              for (int i=0; i < 5; i++)
                 dummy();
           }


   produit
          local         =   100   count   =   1
          local         =   100   count   =   2
          local         =   100   count   =   3
          local         =   100   count   =   4
          local         =   100   count   =   5



POO en C++: Fonctions                             136   © 1997-2003 Fabio HERNANDEZ

Más contenido relacionado

La actualidad más candente

Partie 3: Contrôle d'Exécution — Programmation orientée objet en C++
Partie 3: Contrôle d'Exécution — Programmation orientée objet en C++Partie 3: Contrôle d'Exécution — Programmation orientée objet en C++
Partie 3: Contrôle d'Exécution — Programmation orientée objet en C++Fabio Hernandez
 
Partie 11: Héritage — Programmation orientée objet en C++
Partie 11: Héritage — Programmation orientée objet en C++Partie 11: Héritage — Programmation orientée objet en C++
Partie 11: Héritage — Programmation orientée objet en C++Fabio Hernandez
 
Partie 13: Héritage Multiple — Programmation orientée objet en C++
Partie 13: Héritage Multiple — Programmation orientée objet en C++Partie 13: Héritage Multiple — Programmation orientée objet en C++
Partie 13: Héritage Multiple — Programmation orientée objet en C++Fabio Hernandez
 
Partie 7: Evolution du Modèle Objet — Programmation orientée objet en C++
Partie 7: Evolution du Modèle Objet — Programmation orientée objet en C++Partie 7: Evolution du Modèle Objet — Programmation orientée objet en C++
Partie 7: Evolution du Modèle Objet — Programmation orientée objet en C++Fabio Hernandez
 
Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019Aziz Darouichi
 
Chapitre4: Pointeurs et références
Chapitre4: Pointeurs et références Chapitre4: Pointeurs et références
Chapitre4: Pointeurs et références Aziz Darouichi
 
Développer en natif avec C++11
Développer en natif avec C++11Développer en natif avec C++11
Développer en natif avec C++11Microsoft
 
C++11 en 12 exemples simples
C++11 en 12 exemples simplesC++11 en 12 exemples simples
C++11 en 12 exemples simplesPethrvs
 
Chapitre6: Surcharge des opérateurs
Chapitre6:  Surcharge des opérateursChapitre6:  Surcharge des opérateurs
Chapitre6: Surcharge des opérateursAziz Darouichi
 
Chapitre1: Langage Python
Chapitre1: Langage PythonChapitre1: Langage Python
Chapitre1: Langage PythonAziz Darouichi
 
Les nouveautés de C++11 : Ecrire du C++ Moderne
Les nouveautés de C++11 : Ecrire du C++ ModerneLes nouveautés de C++11 : Ecrire du C++ Moderne
Les nouveautés de C++11 : Ecrire du C++ ModerneMicrosoft
 
Python avancé : Ensemble, dictionnaire et base de données
Python avancé : Ensemble, dictionnaire et base de donnéesPython avancé : Ensemble, dictionnaire et base de données
Python avancé : Ensemble, dictionnaire et base de donnéesECAM Brussels Engineering School
 
Chapitre5: Classes et objets
Chapitre5: Classes et objetsChapitre5: Classes et objets
Chapitre5: Classes et objetsAziz Darouichi
 
Chap 6 : classes et interfaces
Chap 6 : classes et interfacesChap 6 : classes et interfaces
Chap 6 : classes et interfacesAziz Darouichi
 

La actualidad más candente (20)

Partie 3: Contrôle d'Exécution — Programmation orientée objet en C++
Partie 3: Contrôle d'Exécution — Programmation orientée objet en C++Partie 3: Contrôle d'Exécution — Programmation orientée objet en C++
Partie 3: Contrôle d'Exécution — Programmation orientée objet en C++
 
Partie 11: Héritage — Programmation orientée objet en C++
Partie 11: Héritage — Programmation orientée objet en C++Partie 11: Héritage — Programmation orientée objet en C++
Partie 11: Héritage — Programmation orientée objet en C++
 
Partie 13: Héritage Multiple — Programmation orientée objet en C++
Partie 13: Héritage Multiple — Programmation orientée objet en C++Partie 13: Héritage Multiple — Programmation orientée objet en C++
Partie 13: Héritage Multiple — Programmation orientée objet en C++
 
Partie 7: Evolution du Modèle Objet — Programmation orientée objet en C++
Partie 7: Evolution du Modèle Objet — Programmation orientée objet en C++Partie 7: Evolution du Modèle Objet — Programmation orientée objet en C++
Partie 7: Evolution du Modèle Objet — Programmation orientée objet en C++
 
Chap2fonctionscpp
Chap2fonctionscppChap2fonctionscpp
Chap2fonctionscpp
 
Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019
 
Chapitre4: Pointeurs et références
Chapitre4: Pointeurs et références Chapitre4: Pointeurs et références
Chapitre4: Pointeurs et références
 
Chap1: Cours en C++
Chap1: Cours en C++Chap1: Cours en C++
Chap1: Cours en C++
 
Développer en natif avec C++11
Développer en natif avec C++11Développer en natif avec C++11
Développer en natif avec C++11
 
C++11 en 12 exemples simples
C++11 en 12 exemples simplesC++11 en 12 exemples simples
C++11 en 12 exemples simples
 
Chapitre6: Surcharge des opérateurs
Chapitre6:  Surcharge des opérateursChapitre6:  Surcharge des opérateurs
Chapitre6: Surcharge des opérateurs
 
Chapitre1: Langage Python
Chapitre1: Langage PythonChapitre1: Langage Python
Chapitre1: Langage Python
 
Les nouveautés de C++11 : Ecrire du C++ Moderne
Les nouveautés de C++11 : Ecrire du C++ ModerneLes nouveautés de C++11 : Ecrire du C++ Moderne
Les nouveautés de C++11 : Ecrire du C++ Moderne
 
Polymorphisme, interface et classe abstraite
Polymorphisme, interface et classe abstraitePolymorphisme, interface et classe abstraite
Polymorphisme, interface et classe abstraite
 
Python avancé : Ensemble, dictionnaire et base de données
Python avancé : Ensemble, dictionnaire et base de donnéesPython avancé : Ensemble, dictionnaire et base de données
Python avancé : Ensemble, dictionnaire et base de données
 
Chapitre5: Classes et objets
Chapitre5: Classes et objetsChapitre5: Classes et objets
Chapitre5: Classes et objets
 
Polymorphisme
PolymorphismePolymorphisme
Polymorphisme
 
Chap 6 : classes et interfaces
Chap 6 : classes et interfacesChap 6 : classes et interfaces
Chap 6 : classes et interfaces
 
Langage C
Langage CLangage C
Langage C
 
Ch04
Ch04Ch04
Ch04
 

Similar a Partie 4: Fonctions - Programmation orientée objet en C++

02 Spécificité du C++ COURS SYS SYSSSSSS
02 Spécificité du C++  COURS SYS SYSSSSSS02 Spécificité du C++  COURS SYS SYSSSSSS
02 Spécificité du C++ COURS SYS SYSSSSSSAyoubElmrabet6
 
03_Prog_C_Fonctions.pdf
03_Prog_C_Fonctions.pdf03_Prog_C_Fonctions.pdf
03_Prog_C_Fonctions.pdfAhmed12314
 
cpp1 : Quelques elements de base du C++
cpp1 : Quelques elements de base du C++cpp1 : Quelques elements de base du C++
cpp1 : Quelques elements de base du C++Abdoulaye Dieng
 
Seance 3- Programmation en langage C
Seance 3- Programmation en langage C Seance 3- Programmation en langage C
Seance 3- Programmation en langage C Fahad Golra
 
05 - Cours Fonctions.pptx
05 - Cours Fonctions.pptx05 - Cours Fonctions.pptx
05 - Cours Fonctions.pptxBenacerLeila
 
C1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partieC1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partieLoic Yon
 
C++ Metaprogramming : multidimensional typelist
C++ Metaprogramming : multidimensional typelistC++ Metaprogramming : multidimensional typelist
C++ Metaprogramming : multidimensional typelistVincent Agnus
 
Formation python
Formation pythonFormation python
Formation pythonj_lipaz
 
Introduction au langage python notion de base
Introduction au langage python notion de baseIntroduction au langage python notion de base
Introduction au langage python notion de basemohamedAitomar1
 
Introduction au langage python (Notion de base)
Introduction au langage python (Notion de base)Introduction au langage python (Notion de base)
Introduction au langage python (Notion de base)mohamedAitomar1
 
Cours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMACours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMALoic Yon
 
Polymorphisme : un concept polymorphe !
Polymorphisme : un concept polymorphe !Polymorphisme : un concept polymorphe !
Polymorphisme : un concept polymorphe !Aurélien Regat-Barrel
 
Cours de C++, en français, 2002 - Cours 2.1
Cours de C++, en français, 2002 - Cours 2.1Cours de C++, en français, 2002 - Cours 2.1
Cours de C++, en français, 2002 - Cours 2.1Laurent BUNIET
 

Similar a Partie 4: Fonctions - Programmation orientée objet en C++ (20)

02 Spécificité du C++ COURS SYS SYSSSSSS
02 Spécificité du C++  COURS SYS SYSSSSSS02 Spécificité du C++  COURS SYS SYSSSSSS
02 Spécificité du C++ COURS SYS SYSSSSSS
 
POO-chapitre2.pptx
POO-chapitre2.pptxPOO-chapitre2.pptx
POO-chapitre2.pptx
 
03_Prog_C_Fonctions.pdf
03_Prog_C_Fonctions.pdf03_Prog_C_Fonctions.pdf
03_Prog_C_Fonctions.pdf
 
cpp1 : Quelques elements de base du C++
cpp1 : Quelques elements de base du C++cpp1 : Quelques elements de base du C++
cpp1 : Quelques elements de base du C++
 
Seance 3- Programmation en langage C
Seance 3- Programmation en langage C Seance 3- Programmation en langage C
Seance 3- Programmation en langage C
 
C4 fonctions
C4 fonctionsC4 fonctions
C4 fonctions
 
Theme 7
Theme 7Theme 7
Theme 7
 
05 - Cours Fonctions.pptx
05 - Cours Fonctions.pptx05 - Cours Fonctions.pptx
05 - Cours Fonctions.pptx
 
Ch07
Ch07Ch07
Ch07
 
C1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partieC1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partie
 
C++ Metaprogramming : multidimensional typelist
C++ Metaprogramming : multidimensional typelistC++ Metaprogramming : multidimensional typelist
C++ Metaprogramming : multidimensional typelist
 
Formation python
Formation pythonFormation python
Formation python
 
Ch08
Ch08Ch08
Ch08
 
Theme 6
Theme 6Theme 6
Theme 6
 
Introduction au langage python notion de base
Introduction au langage python notion de baseIntroduction au langage python notion de base
Introduction au langage python notion de base
 
Introduction au langage python (Notion de base)
Introduction au langage python (Notion de base)Introduction au langage python (Notion de base)
Introduction au langage python (Notion de base)
 
Cours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMACours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMA
 
Polymorphisme : un concept polymorphe !
Polymorphisme : un concept polymorphe !Polymorphisme : un concept polymorphe !
Polymorphisme : un concept polymorphe !
 
Cours de C++, en français, 2002 - Cours 2.1
Cours de C++, en français, 2002 - Cours 2.1Cours de C++, en français, 2002 - Cours 2.1
Cours de C++, en français, 2002 - Cours 2.1
 
C++11
C++11C++11
C++11
 

Partie 4: Fonctions - Programmation orientée objet en C++

  • 1. Programmation Orientée Objet en C++ 4ème Partie: Fonctions Fabio Hernandez Fabio.Hernandez@in2p3.fr
  • 2. Vue d'Ensemble Notions de base Types, variables, opérateurs Contrôle d'exécution Fonctions Mémoire dynamique Qualité du logiciel Evolution du modèle objet Objets et classes Fonctions membres Classes génériques Héritage Polymorphisme Héritage multiple Entrée/sortie POO en C++: Fonctions 108 © 1997-2003 Fabio HERNANDEZ
  • 3. Table des Matières Déclaration de la Fonction Utilisation de la Fonction Prototype de Fonction Contrôle de Type Valeur de Retour Signature de Fonction Passage des Arguments Tableau comme Argument Fonctions Inline Portée des Variables Durée de Vie des Variables POO en C++: Fonctions 109 © 1997-2003 Fabio HERNANDEZ
  • 4. Déclaration de la Fonction Une fonction est une opération définie par le programmeur Les opérandes sont les paramètres de la fonction Exemple type de la nom de la valeur de fonction liste des retour paramètres int min(int a, int b) { corps de la fonction return (a < b) ? a : b; } POO en C++: Fonctions 110 © 1997-2003 Fabio HERNANDEZ
  • 5. Utilisation de la Fonction Toute fonction doit être déclarée avant son utilisation #include <iostream> // C++ standard I/O declarations extern int min(int a, int b); int main() { int value1; int value2; cout << "Enter two integers: " << endl; cin >> value1 >> value2; cout << "The minimun between: " << value1 << " and " << value2 << " is " << min(value1, value2) << endl; return 0; } POO en C++: Fonctions 111 © 1997-2003 Fabio HERNANDEZ
  • 6. Prototype de Fonction Une fonction ne peut être définie qu'une seule fois dans un programme Mais peut être utilisée autant de fois que nécessaire Généralement, elle est définie dans un fichier .cpp avec d'autres fonctions et utilisée dans des modules différents Le moyen de déclarer une fonction est le prototype extern int min(int a, int b); L'objectif du prototype est d'informer le compilateur du type de la valeur de retour, du nombre de paramètres et du type de chacun POO en C++: Fonctions 112 © 1997-2003 Fabio HERNANDEZ
  • 7. Prototype de Fonction (suite) Associé à chaque module (fichier .cpp) il faut créer un fichier avec les prototypes des fonctions définies dans celui-ci Ce fichier de prototypes sera inclus via une instruction pré-processeur dans tous les autres modules qui utilisent une ou plusieurs de ces fonctions Exemple: supposons que dans le fichier util.cpp se trouvent les définitions des fonctions min et abs suivantes int min(int a, int b) { return (a < b) ? a : b; } int abs(int a) { return (a < 0) ? -a : a; } POO en C++: Fonctions 113 © 1997-2003 Fabio HERNANDEZ
  • 8. Prototype de Fonction (suite) Nous créons le fichier util.prt (le nom n'a pas d'importance pour le compilateur mais en a pour le programmeur) avec les déclarations suivantes extern int min(int a, int b); extern int abs(int a); Ce fichier peut maintenant être inclus dans tout module (fichier .cpp) nécessitant une des fonctions définies dans util.cpp #include <iostream> #include "util.prt" int main() { cout << "The absolute value of -345 is: " << abs(-345) << endl; return 0; } POO en C++: Fonctions 114 © 1997-2003 Fabio HERNANDEZ
  • 9. Contrôle de Type C++ est un langage fortement typé Le type de la valeur de retour et de chacun des arguments d'une fonction sont contrôlés en compilation S'il y a des différences entre le type de la déclaration et le type des arguments utilisés dans l'invocation de la fonction une conversion implicite est effectuée si possible (probablement avec warning) int i = min(234, 78.90); // conversion a int 78 autrement, une erreur est détectée et la compilation échoue int i = min(234, "a string"); // ERROR Le nombre d'arguments est aussi contrôlé POO en C++: Fonctions 115 © 1997-2003 Fabio HERNANDEZ
  • 10. Valeur de Retour Peut être d'un type fondamental (int, long,...), d'un type dérivé (int*) ou d' un type défini par le programmeur enum Color {Black, White}; Color getComplementaryColor(Color currentColor) { return (currentColor == Black) ? White : Black; } Le type void est utilisé pour signifier l'absence de valeur de retour void printError(const char* message) { cerr << "ERROR: " << message << endl; } L'instruction return n'est pas strictement nécessaire pour une fonction qui retourne void POO en C++: Fonctions 116 © 1997-2003 Fabio HERNANDEZ
  • 11. Signature de Fonction La liste des arguments de la fonction est connue comme la signature de la fonction Le nom et la signature de la fonction identifient pleinement chaque fonction Exemple: float min(float a, float b) { return (a < b) ? a : b; } est différente de la fonction min vue précédemment POO en C++: Fonctions 117 © 1997-2003 Fabio HERNANDEZ
  • 12. Signature de Fonction (suite) Lors de l'invocation de la fonction, le compilateur choisit entre les différentes possibilités, selon le type des arguments extern float min(float a, float b); extern int min(int a, int b); void main() { const float f1 = 0.234; const float f2 = 34.90; const int i1 = 190; int intMin = min(i1, 250); // min(int, int) is called float floatMin = min(f1, f2); // min(float, float) is called } POO en C++: Fonctions 118 © 1997-2003 Fabio HERNANDEZ
  • 13. Signature de Fonction (suite) Le type de la valeur de retour ne fait pas partie de la signature int min(short a, short b); short min(short a, short b); // ERROR: same name and signature POO en C++: Fonctions 119 © 1997-2003 Fabio HERNANDEZ
  • 14. Passage des Arguments Les arguments des fonctions en C++ sont passés par valeur Une copie de la valeur de chaque argument est copiée dans la pile d'exécution de la fonction Les modifications faites à ces valeurs affectent uniquement les copies et ne sont pas reflétées dans les arguments actuels Exemple: soit la fonction void increment(int value) { value += 1; } POO en C++: Fonctions 120 © 1997-2003 Fabio HERNANDEZ
  • 15. Passage des Arguments (suite) extern increment(int i); void main() { int counter=100; cout << "Before increment, counter is = " << counter << endl; increment(counter); cout << "After increment, counter is = " << counter << endl; } produit Before increment, counter is = 100 After increment, counter is = 100 POO en C++: Fonctions 121 © 1997-2003 Fabio HERNANDEZ
  • 16. Passage des Arguments (suite) Le passage des arguments par valeur n'est pas toujours souhaitable quand la fonction doit changer la valeur des arguments quand l'argument de la fonction est un objet de grande taille: le coût en temps et en mémoire de la copie serait très élevé Deux façons de passer les arguments par référence utilisation des pointeurs void increment(int* value) { *value += 1; } à l'invocation, l'argument de la fonction est l'adresse de l'objet et pas l'objet lui même POO en C++: Fonctions 122 © 1997-2003 Fabio HERNANDEZ
  • 17. Passage des Arguments (suite) extern increment(int* value); void main() { int counter=100; cout << "Before increment, counter is = " << counter << endl; increment(&counter); // pass the address of count cout << "After increment, counter is = " << counter << endl; } produit Before increment, counter is = 100 After increment, counter is = 101 POO en C++: Fonctions 123 © 1997-2003 Fabio HERNANDEZ
  • 18. Passage des Arguments (suite) Deux façons de passer les arguments par référence (suite) utilisation des références void increment(int& value) { value += 1; } void main() { int counter=100; cout << "Before increment, counter is = " << counter << endl; increment(counter); cout << "After increment, counter is = " << counter << endl; } produit Before increment, counter is = 100 After increment, counter is = 101 POO en C++: Fonctions 124 © 1997-2003 Fabio HERNANDEZ
  • 19. Tableau comme Argument Les tableaux en C++ ne sont jamais passés par valeur Un tableau est passé comme un pointeur à son premier élément (celui de la position zéro) Conséquences: tout changement fait à un tableau à l'intérieur d'une fonction est effectué au tableau lui même et pas à une copie la taille du tableau (le nombre de positions) ne fait pas partie du type: la fonction ne connaît donc pas cette taille POO en C++: Fonctions 125 © 1997-2003 Fabio HERNANDEZ
  • 20. Tableau comme Argument (suite) Exemple void printArray(int* array, int howmany) { cout << "["; for (int pos=0; pos < howmany; pos++) La taille du tableau cout << " " << array[pos]; est aussi un cout << " ]" << endl; paramètre } void incrementArray(int* array, int howmany) { for (int pos=0; pos < howmany; pos++) array[pos] += 100; } POO en C++: Fonctions 126 © 1997-2003 Fabio HERNANDEZ
  • 21. Tableau comme Argument (suite) Exemple (suite) void main() { const int MaxItems = 5; int itemTable[MaxItems]={5, 10, 15, 20, 25}; cout << "Originally, itemTable is: "; printArray(itemTable, MaxItems); incrementArray(itemTable, MaxItems); cout << "After increment, itemTable is: "; printArray(itemTable, MaxItems); } produit Originally, itemTable is: [ 5 10 15 20 25 ] After increment, itemTable is: [ 105 110 115 120 125 ] POO en C++: Fonctions 127 © 1997-2003 Fabio HERNANDEZ
  • 22. Tableau comme Argument (suite) Exemple (suite) La fonction printArray ne modifie pas le tableau passé en argument On devrait donc la définir de la façon suivante void printArray(const int* array, int howmany) { cout << "["; for (int pos=0; pos < howmany; pos++) cout << " " << array[pos]; cout << " ]" << endl; } POO en C++: Fonctions 128 © 1997-2003 Fabio HERNANDEZ
  • 23. Fonctions Inline Parfois le temps d'exécution d'une fonction est petit comparé au temps nécessaire pour appeler la fonction Le mot clé inline informe le compilateur qu'un appel à cette fonction peut être remplacé par le corps de la fonction Exemple inline int max(int a, int b) { return (a < b) ? b : a; } void main() { int m = max(134, 876); } POO en C++: Fonctions 129 © 1997-2003 Fabio HERNANDEZ
  • 24. Fonctions Inline (suite) Le compilateur génère le code équivalent à l'expansion de la fonction, comme si l'on avait écrit void main() { int m = (134 < 876) ? 876 : 134; } Conséquences: programme plus rapide programme plus gros Les fonctions inline doivent être définies dans des fichiers d'entête (.h) qui seront inclus dans des fichiers source (.cpp), pour que le compilateur puisse faire l'expansion POO en C++: Fonctions 130 © 1997-2003 Fabio HERNANDEZ
  • 25. Portée des Variables Une définition de variable introduit un identificateur Il ne peut être utilisé que dans une partie du source du programme (portée) Une variable définie à l'intérieur d'une fonction (variable locale) peut être utilisée à partir de sa définition jusqu'à la fin du bloc où la définition apparaît void swap(int& a, int& b) { int temp = a; // temp is a local variable a = b; b = temp; } POO en C++: Fonctions 131 © 1997-2003 Fabio HERNANDEZ
  • 26. Portée des Variables (suite) Une variable définie en dehors d'une fonction ou d'une classe, (variable globale), est visible à partir de sa définition jusqu'à la fin du fichier source (.cpp) où sa définition apparaît Une variable peut être définie dans un bloc avec le même nom qu'un identificateur déjà existant: dans ce cas, cette variable cache la variable du bloc externe ou la variable globale qui porte le même nom POO en C++: Fonctions 132 © 1997-2003 Fabio HERNANDEZ
  • 27. Portée des Variables (suite) Exemple int count; // global variable void dummy() { int count; // local count, hides global count = 100; // modifies local count while (count > 0) { // do something --count; } } void increment() { count += 1; // modifies global count } POO en C++: Fonctions 133 © 1997-2003 Fabio HERNANDEZ
  • 28. Durée de Vie des Variables Lors de l'exécution du programme, chaque objet est créé quand sa définition apparaît et est détruit quand son identificateur sort de contexte En particulier, les variables locales sont créées (allocation de mémoire dans la pile d'exécution) au moment de l'invocation (activation) de la fonction Elles disparaissent quand la fonction finit son exécution Les variables(objets) globales sont créées et initialisées une seule fois et existent jusqu'à la fin de l'exécution du programme POO en C++: Fonctions 134 © 1997-2003 Fabio HERNANDEZ
  • 29. Durée de Vie des Variables (suite) A l'aide du mot clé static le programmeur peut définir une variable locale de façon à ce qu'elle existe jusqu'à la fin du programme Ce type des variables sont initialisées une seule fois Exemple void dummy() { static int count=1; // created and initialized // only once int local=100; // created and initialized // at each call cout << " local = " << local << << " count = " << count << endl; ++count; } POO en C++: Fonctions 135 © 1997-2003 Fabio HERNANDEZ
  • 30. Durée de Vie des Variables (suite) Exemple (suite) void main() { for (int i=0; i < 5; i++) dummy(); } produit local = 100 count = 1 local = 100 count = 2 local = 100 count = 3 local = 100 count = 4 local = 100 count = 5 POO en C++: Fonctions 136 © 1997-2003 Fabio HERNANDEZ