Docstoc

slides

Document Sample
slides Powered By Docstoc
					      Cours de C++
         c
     Fran¸ois Laroussinie
Dept. d’Informatique, ENS de Cachan


       2 novembre 2005
     e
Premi`re partie I

  Introduction
Introduction
Introduction


Algorithme et programmation


                            e            e               e
               Algorithme: m´thode pour r´soudre un probl`me
                              e         e
               Pour un probl`me donn´, il peut y avoir plusieurs
               algorithmes. . . ou aucun !
                                             e        e
               NB: pour la plupart des probl`mes int´ressants, il n’existe pas
               d’algorithme (ni aujourd’hui, ni demain !)
                             e                                  e
               Dans les probl`mes qui restent, la grande majorit´ ont des
                                                     e        e
               algorithmes beaucoup trop durs pour ˆtre utilis´s !
                                                            ee
               On cherche des algorithmes simples, efficaces, ´l´gants. . .

                                          a
               Programme: . . . s’adresse ` une machine !
Introduction


Le langage C++



                e
               D´but en 1983.
                 e
               Am´lioration du langage C:

                                  e
               Abstraction de donn´es
                                   e
               Programmation orient´e objet
                              e e
               Programmation g´n´rique

                 e        e
               tr`s utilis´ !
Introduction


Programmer


                      e
        Une fois trouv´ l’algorithme, programmer en C++ comporte 3
        phases:
                                               e
           1. Editer le programme – avec votre ´diteur de texte favori. . .
Introduction


Programmer


                      e
        Une fois trouv´ l’algorithme, programmer en C++ comporte 3
        phases:
                                               e
           1. Editer le programme – avec votre ´diteur de texte favori. . .
           2. Compiler le programme (avec g++)
Introduction


Programmer


                      e
        Une fois trouv´ l’algorithme, programmer en C++ comporte 3
        phases:
                                               e
           1. Editer le programme – avec votre ´diteur de texte favori. . .
           2. Compiler le programme (avec g++)
                e
           3. Ex´cuter le programme
Introduction


Programmer


                      e
        Une fois trouv´ l’algorithme, programmer en C++ comporte 3
        phases:
                                               e
           1. Editer le programme – avec votre ´diteur de texte favori. . .
           2. Compiler le programme (avec g++)
                e
           3. Ex´cuter le programme
        ...
           4. TESTER et DEBUGGER : retour au point 1 !

        ¸
        Ca peut durer assez longtemps...
Introduction


Un exemple


            e
        L’in´vitable hello world:

       #i n c l u d e <i o s t r e a m >

        u s i n g namespace s t d ;

        i n t main ( ) {

               c o u t << ” h e l l o w o r l d ! ” << e n d l ;

        }


         e
        D´mo...
         e
    Deuxi`me partie II

Structures de base du C++
Plan


Plan
       2    Types, variables...
       3    Expressions
       4    Instructions
       5        e
            Entr´es - Sorties
       6    Exemples
       7    Evaluation des expressions
       8               e e
            Structure g´n´rale d’un programme C++
       9        e
            Proc´dures et fonctions
       10    e        e
            R´cursivit´
       11        e
            Compl´ments sur les fonctions
       12       e            e     e
            Port´e, visibilit´, dur´e de vie des variables
       13        e
            Compl´ments
Plan


Programmation



       Les briques de base du langage:

                                            e
           Ce qui permet de stocker des donn´es: types, variables,
           tableaux, etc.

                                                               e
           Les expressions qui permettent de manipuler les donn´es.

           Les instructions pour construire les algorithmes.
Types, variables...


Plan
       2     Types, variables...
       3     Expressions
       4     Instructions
       5         e
             Entr´es - Sorties
       6     Exemples
       7     Evaluation des expressions
       8                e e
             Structure g´n´rale d’un programme C++
       9         e
             Proc´dures et fonctions
      10      e        e
             R´cursivit´
      11          e
             Compl´ments sur les fonctions
      12         e            e     e
             Port´e, visibilit´, dur´e de vie des variables
      13          e
             Compl´ments
Types, variables...


      ee
Types ´l´mentaires


                 int : entiers (au min 16 bits, pour des valeurs ≤ 32767)
                 (d’autres formats existent: long int (min 32 bits), short
                 int, unsigned int) . . .
                                                              a
                 (float), double et long double : nombres ` virgule
                               e e
                 flottante (en g´n´ral 15 chiffres sign. pour double).
                 Par ex. 23.3 ou 2.456e12 ou 23.56e − 4
                              e
                 char : caract`res (’a’,’b’,. . . ’A’,. . . ,’:’,. . . ).
                             e
                 bool : bool´ens (’true’ ou ’false’).
                                                      e        a
                 (Et: 0 ≡ false ; tout entier non nul ´quivaut ` false)
        (Et aussi: des types particuliers pour les tailles de tableaux, de
           ınes de caract`res, d’objets etc. size t, ::size type)
        chaˆ              e
Types, variables...


 e
D´finition de variable


        Syntaxe : type v ;
        int p ;
        double x ;
                                     e     e             e          e
                 Toute variable doit ˆtre d´finie avant d’ˆtre utilis´e !
                       e                  ıtre         u
                 Une d´finition peut apparaˆ n’importe o` dans un
                 programme.
                                   e           a                  e
                 Une variable est d´finie jusqu’` la fin de la premi`re instruction
                 compos´e (marqu´e par }) qui contient sa d´finition.
                        e          e                           e
                                e
                 (Une variable d´finie en dehors de toute fonction – et de tout
                 espace de nom – est une variable globale).
Types, variables...


 e
D´finition de variable



                          e             e              e
        Une variable peut ˆtre initialis´e lors de sa d´claration, deux
        notations sont possibles :

        int p=34 ;                            int p (34) ;
        double x=12.34 ;                      double x (12.34) ;

                                ee                                e
        Une variable d’un type ´l´mentaire qui n’est pas initialis´e, n’a pas
                   e
        de valeur d´finie: elle peut contenir n’importe quoi.
Types, variables...


Constantes symboliques




        Syntaxe : const type nom = val;

        Par exemple: const int Taille = 100 ;

        Il ne sera pas possible de modifier Taille dans le reste du
                             a
        programme (erreur ` la compilation). . .
Types, variables...


   ınes de caract`res
Chaˆ             e

                                                             ee
        Il existe une classe string, ce n’est un pas un type ´l´mentaire.
                                         e
        Pour l’utiliser, il faut placer tˆte du fichier :
        # include <string>

                             e
                 string t ; d´finit t comme une variable...
                 string s(25,’a’) ;
                 string mot = "bonjour" ;
                              e
                 s.size() repr´sente la longueur de s
                               e         e
                 s[i] est le i-`me caract`re de s ( i = 0,1,. . . s.size()-1)
                                         ıne             a          e
                 s+t est une nouvelle chaˆ correspondant ` la concat´nation
                 de s et t.

                                            ıne        e
        NB: il existe une autre sorte de chaˆ de caract`res en C/C++
Types, variables...


Tableaux

                                                           e
        Pour utiliser la classe vector, il faut placer en tˆte du fichier :
        # include <vector>
                          e
        Un tableau est typ´:
        vector<int> Tab(100,5) ;
        vector<int> Tab(50) ;
        vector<double> T ;
                   e e
        Structure g´n´rale: vector< type > Nom(n,v ) ;
                 vector< type > Nom1 = Nom2 ;
                                                        e
                 → les valeurs de Nom2 sont alors recopi´es dans Nom1.
                                     a
                 T.size() correspond ` la taille de T.
                                                              e
                 NB: size() renvoie en fait un entier non sign´, son type
                 exact est vector<type>::size type
Types, variables...


Tableaux



                       e           e   ee
                 T[i] d´signe le i-`me ´l´ment avec i = 0, . . . T.size()-1.

                                         e                a
                 vector<vector<int> > T d´finit un tableau ` deux
                 dimensions.
                 Pour l’initialiser, on peut utiliser l’instruction suivante :
                 vector<vector<int> >
                 T2(100,vector<int>(50,1)) ;
                 . . . on initialise chacune des 100 cases de T1 avec un tableau
                 de taille 50 rempli de 1.
Expressions


Plan
      2       Types, variables...
      3       Expressions
      4       Instructions
      5           e
              Entr´es - Sorties
      6       Exemples
      7       Evaluation des expressions
      8                  e e
              Structure g´n´rale d’un programme C++
      9           e
              Proc´dures et fonctions
     10        e        e
              R´cursivit´
     11            e
              Compl´ments sur les fonctions
     12           e            e     e
              Port´e, visibilit´, dur´e de vie des variables
     13            e
              Compl´ments
Expressions


Affectation




        En C/C++, l’affectation est une expression:
        Soient v une variable (au sens large) et expr une expression.
                                           a
        v = expr affecte la valeur de expr ` la variable v et retourne la
                    e a           e
        valeur affect´e ` v comme r´sultat.

                                          a        a
        Par exemple, i = (j = 0) affecte 0 ` j puis ` i et retourne 0 !!
Expressions


  e
Op´rateurs classiques


                 e                e
              Op´rateurs arithm´tiques:
                                       e       e
              *, +, -, / (division enti`re et r´elle), % (modulo)

                 e
              Op´rateurs de comparaison
                    e               e         e          e            e
              < (inf´rieur), <= (inf´rieur ou ´gal), == (´gal), > (sup´rieur),
                      e         e                e
              >= (sup´rieur ou ´gal) et != (diff´rent)

                 e             e
              Op´rateurs bool´ens
                     e           e                   e
              && repr´sente l’op´rateur “ET”, || repr´sente le “OU”, et !
                  e
              repr´sente le “NON”.
              Par exemple, ((x<12) && ((y>0) || !(z>4)))
Expressions


  e             e
Pr´ et Post incr´ment



                        e
              ++var incr´mente la variable var et retourne la nouvelle valeur.
                   e        a
              (++i ´quivaut ` i=i+1)

                         e
              var ++ incr´mente la variable var et retourne l’ancienne valeur.
                   e        a
              (i++ ´quivaut ` (i=i+1)-1)

                                                         e
        En dehors d’une expression, i++ et ++i sont donc ´quivalentes.
Expressions


  e          e e
Pr´ et Post d´cr´ment




                                  e e
              L’expression --var d´cr´mente la variable var et retourne la
              nouvelle valeur.

                                   e e
              L’expression var -- d´cr´mente la variable var et retourne
              l’ancienne valeur.
Instructions


Plan
       2       Types, variables...
       3       Expressions
       4       Instructions
       5           e
               Entr´es - Sorties
       6       Exemples
       7       Evaluation des expressions
       8                  e e
               Structure g´n´rale d’un programme C++
       9           e
               Proc´dures et fonctions
      10        e        e
               R´cursivit´
      11            e
               Compl´ments sur les fonctions
      12           e            e     e
               Port´e, visibilit´, dur´e de vie des variables
      13            e
               Compl´ments
Instructions


Instructions usuelles

                e
               d´finition de variables, fonctions, types etc.
               expr ;
               { liste d’instructions }                       e
                                          : instruction compos´e.
               if (expr ) instr
               if (expr ) instr1 else instr2
               if (v == 3) i =i+4 ;

               if ((v==3) && (i<5))
                  { i=i+4 ;
                   v=v*2 ;}
                 else v=i ;
               r = r*3 ;
Instructions


La boucle FOR
        for (expr1 ;expr2 ;expr3 ) instr

                                                                                                                    




                                                                                                                                            '   (   )




                                                ¡           ¢                       £   ¤                   ¥       ¦       §




                                                                                                                                    #




                                                    #               $               %                                           &       &




                                                                                              !       "




                                            ¨               ©                                                 




        Ex: for(i=0 ;i<235 ;i=i+1) cout << T[i] ;
        for(i=0,j=1 ;i<235 ;i=i+1,j=j+3) cout << T[i][j] ;
Instructions


La boucle WHILE

        while (expr ) instr




                                      ¡       ¢               £           ¤   ¥       ¦




                                                                                                         




                                                        




                                  §                   ¨           ©              
Instructions


La boucle DO

        do instr while (expr ) ;




                              §   ¨   ©




                                              ¡       ¢       £           ¤   ¥           ¦




                                                                                 §   




                                                                
    e
Entr´es - Sorties


Plan
       2    Types, variables...
       3    Expressions
       4    Instructions
       5        e
            Entr´es - Sorties
       6    Exemples
       7    Evaluation des expressions
       8               e e
            Structure g´n´rale d’un programme C++
       9        e
            Proc´dures et fonctions
      10     e        e
            R´cursivit´
      11         e
            Compl´ments sur les fonctions
      12        e            e     e
            Port´e, visibilit´, dur´e de vie des variables
      13         e
            Compl´ments
    e
Entr´es - Sorties


       a e
Afficher ` l’´cran


                              e
        Pour utiliser les entr´es/sorties, il faut ajouter:
        # include <iostream>
        Syntaxe : cout < < expr1 < < . . . < < exprn ;
        Cette instruction affiche expr1 puis expr2 . . .

        Afficher un saut de ligne se fait au moyen de cout < < endl.

         int i=45 ;
        cout << "la valeur de i est " << i << endl ;
    e
Entr´es - Sorties


       a e
Afficher ` l’´cran

        Syntaxe : cout < < expr1 < < . . . < < exprn ;

                                         e
                    cout (ou std::cout) d´signe le “flot de sortie” standard.
                                 e
                    < < est un op´rateur binaire:
                                       e
                        le premier op´rande est cout (de type “flot de sortie”)
                                      e                      a
                        le second op´rande est l’expression ` afficher
                            e
                        le r´sultat est de type “flot de sortie’

                                                 a
                    < < est associatif de gauche ` droite
                                    e           e                     e    e
                    < < est surcharg´ (ou sur-d´fini): on utilise le mˆme op´rateur
                                             e                      e
                    pour afficher des caract`res, des entiers, des r´els ou des
                    chaˆ              e
                        ınes de caract`res etc.
    e
Entr´es - Sorties


Lire au clavier


        Syntaxe : cin > > var1 > > . . . > > varn ;

                                                                     a
        Cette instruction lit (au clavier) des valeurs et les affecte ` var1
        puis var2 . . .
                             e                            e                 a
        cin est le flot d’entr´e standard, et > > est un op´rateur similaire `
        < <.

                   e       e                          e
        Les caract`res tap´s au clavier sont enregistr´s dans un buffer dans
        lequel les cin viennent puiser des valeurs. Les espaces, les
                                                   e
        tabulations et les fins de lignes sont des s´parateurs.
Exemples


Plan
      2    Types, variables...
      3    Expressions
      4    Instructions
      5        e
           Entr´es - Sorties
      6    Exemples
      7    Evaluation des expressions
      8               e e
           Structure g´n´rale d’un programme C++
      9        e
           Proc´dures et fonctions
     10     e        e
           R´cursivit´
     11         e
           Compl´ments sur les fonctions
     12        e            e     e
           Port´e, visibilit´, dur´e de vie des variables
     13         e
           Compl´ments
Exemples


Exemples...




           chaine.cc

           tab.cc

           es.cc
Evaluation des expressions


Plan
      2     Types, variables...
      3     Expressions
      4     Instructions
      5         e
            Entr´es - Sorties
      6     Exemples
      7     Evaluation des expressions
      8                e e
            Structure g´n´rale d’un programme C++
      9         e
            Proc´dures et fonctions
      10     e        e
            R´cursivit´
      11         e
            Compl´ments sur les fonctions
      12        e            e     e
            Port´e, visibilit´, dur´e de vie des variables
      13         e
            Compl´ments
Evaluation des expressions


Evaluation des expressions
               e       e
        Priorit´ des op´rateurs :

                x[y]           x++         x--
                ++x          --x      !x         -x
                x*y          x/y      x% y
                x+y          x-y
                x >> y             x << y
                x < y          x > y        x >= y    x <= y
                x == y             x != y
                x && y
                x || y
                x = y          x op= y
                x? y : z
Evaluation des expressions


                               e
Evaluation des expressions bool´ennes



                                                           e    e
                Dans e1 && e2, la sous-expression e2 n’est ´valu´e que si e1
                  eee      e a
                a ´t´ ´valu´e ` ’true’.
                if (i >=0 && T[i] > 20) blabla

                                                           e    e
                Dans e1 || e2, la sous-expression e2 n’est ´valu´e que si e1
                  eee      e a
                a ´t´ ´valu´e ` ’false’.
                if (i<0 || T[i] > 20) blabla
Evaluation des expressions


                                 e
Evaluation des expressions arithm´tiques


                                    e
        Si une (sous-)expression m´lange plusieurs types, c’est le type le
                                 e
        plus large qui est utilis´.
        int i=3,j=2,m ;
        double r=3.4 ;
        m = (i/j)*r ;
                                                e    e     e
                D’abord l’expression (i/j) est ´valu´e: / d´signe ici la
                             e
                division enti`re, cela donne donc 1.
                      e
                Pour ´valuer le produit 1*r, il faut convertir 1 en double
                (1.0) et faire le produit sur les doubles, cela donne 3.4
                Pour l’affectation, comme m est entier, 3.4 est converti en
                int. Finalement on a m = 3.
Evaluation des expressions


                                 e
Evaluation des expressions arithm´tiques

               e
        • Pour ´viter les erreurs, il est possible de convertir explicitement
                 e
        des donn´es d’un certain type en un autre.
        Par exemple:
        int i=3,j=2,m ;
        double r=3.4 ;
        m = (double(i)/j)*r ;
        Donne...
Evaluation des expressions


                                 e
Evaluation des expressions arithm´tiques

               e
        • Pour ´viter les erreurs, il est possible de convertir explicitement
                 e
        des donn´es d’un certain type en un autre.
        Par exemple:
        int i=3,j=2,m ;
        double r=3.4 ;
        m = (double(i)/j)*r ;
        Donne... 5 !
Evaluation des expressions


                                 e
Evaluation des expressions arithm´tiques

               e
        • Pour ´viter les erreurs, il est possible de convertir explicitement
                 e
        des donn´es d’un certain type en un autre.
        Par exemple:
        int i=3,j=2,m ;
        double r=3.4 ;
        m = (double(i)/j)*r ;
        Donne... 5 !

            e                                 e
        • L’´valuation d’une expression arithm´tique ne se fait pas toujours
                   a
        de gauche ` droite !
        Ex: (i/j)*(r/3)

          e
        (d´mo)
           e e
Structure g´n´rale d’un programme C++


Plan
      2    Types, variables...
      3    Expressions
      4    Instructions
      5        e
           Entr´es - Sorties
      6    Exemples
      7    Evaluation des expressions
      8               e e
           Structure g´n´rale d’un programme C++
      9        e
           Proc´dures et fonctions
     10     e        e
           R´cursivit´
     11         e
           Compl´ments sur les fonctions
     12        e            e     e
           Port´e, visibilit´, dur´e de vie des variables
     13         e
           Compl´ments
           e e
Structure g´n´rale d’un programme C++


           e e
Structure g´n´rale d’un programme



                             e
       Un programme C++ est r´parti dans un ou plusieurs fichiers.
                                   e          e
       Chacun peut contenir des d´finitions/d´clarations de fonctions, des
        e                          e
       d´finitions de types et des d´finitions de variables globales.
       Il existe une seule fonction main: c’est la fonction qui sera
          e e        e
       ex´cut´e apr`s la compilation.
       Le profil de main est : int main() ou int main( int argc,
       char ** argv ) pour passer des arguments.
       Exemple de programme complet. . .
           e e
Structure g´n´rale d’un programme C++


           e e
Structure g´n´rale d’un programme


       Un programme complet:
       #include <iostream>

       void test(int j)
       { cout << j << endl ; }

       int main()
       {
       int i =20 ;
       cout << "bonjour" << endl ;
       test(i) ;
       }
    e
Proc´dures et fonctions


Plan
      2     Types, variables...
      3     Expressions
      4     Instructions
      5         e
            Entr´es - Sorties
      6     Exemples
      7     Evaluation des expressions
      8                e e
            Structure g´n´rale d’un programme C++
      9         e
            Proc´dures et fonctions
      10     e        e
            R´cursivit´
      11         e
            Compl´ments sur les fonctions
      12        e            e     e
            Port´e, visibilit´, dur´e de vie des variables
      13         e
            Compl´ments
    e
Proc´dures et fonctions


   e
  D´finition de fonction

        type                            e
                    nom( liste des param`tres) { corps }
                                      e
                type est le type du r´sultat de la fonction.
                                             e
                (void si il s’agit d’une proc´dure)
                                  e
                La liste des param`tres (param`tres formels):
                                              e
                type1 p1, ..., typen pn
                          e                      a
                Le corps d´crit les instructions ` effectuer.
                                                                    e
                Le corps utilise ses propres variables locales, les ´ventuelles
                                                e
                variables globales et les param`tres formels.
                                            e
                Si une fonction renvoie un r´sultat, il doit y avoir (au moins)
                une instruction return expr ;
                                      e
                Dans le cas d’une proc´dure, on peut utiliser: return ;
    e
Proc´dures et fonctions


Exemple




          int max(int a,int b)
        {
        int res=b ;
        if (a>b) res = a ;
        return res ;
        }
    e
Proc´dures et fonctions


Appel d’une fonction




        nom(liste des arguments)
        La liste des arguments (param`tres r´els) est expr1 , expr2 , . . . exprn
                                     e      e
         u
        o` chaque expri est compatible avec le type typei du param`tre  e
        formel pi.
        Exemple :
         int k=34, t=5, m ;
        m = max(k,2*t+5) ;
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;
               return res ; }
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x”
               return res ; }
                                      “y”
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x” 5
               return res ; }
                                      “y”
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x” 5
               return res ; }
                                      “y” 10
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x” 5
               return res ; }
                                      “y” 10
               ...
                                      “z”
               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x” 5
               return res ; }
                                      “y” 10   “a” 10
               ...
                                      “z”      “b” 5
               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x” 5
               return res ; }
                                      “y” 10   “a” 10
               ...
                                      “z”      “b” 5
               int main() {
               int x,y ;                       “res” 5
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x” 5
               return res ; }
                                      “y” 10   “a” 10
               ...
                                      “z”      “b” 5
               int main() {
               int x,y ;                       “res” 10
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x” 5
               return res ; }
                                      “y” 10   “a” 10
               ...
                                      “z”      “b” 5
               int main() {
               int x,y ;                       “res” 10
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x” 5
               return res ; }
                                      “y” 10
               ...
                                      “z” 10
               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;       “x” 5
               return res ; }
                                        “y” 10
               ...
                                        “z” 10
               int main() {
                                          ———————————–
               int x,y ;
               x=5 ;                  z = 10
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;
               return res ; }
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
               Fin
    e
Proc´dures et fonctions


  Afficher le contenu d’un tableau d’entiers




          void AfficherTab(vector<int> T)
        {
        for (int i=0 ; i< T.size() ; i++)
           cout << T[i] << " " ;
        }
    e
Proc´dures et fonctions


  Saisie d’un tableau d’entiers
    e
Proc´dures et fonctions


  Saisie d’un tableau d’entiers


          vector<int> SaisieTab()
        {
        int taille ;
        cout << " Entrer une taille : " ;
        cin >> taille ;
        vector<int> res(taille,0) ;

        for (int i=0 ; i< taille ; i++) {
           cout << " val = " ;
           cin >> res[i] ;
        }
        return res ;
        }
    e
Proc´dures et fonctions


                          ee
  Recherche du plus grand ´l´ment
    e
Proc´dures et fonctions


                          ee
  Recherche du plus grand ´l´ment


          int Recherche(vector<int> T)
        {
        if (T.size()==0) {
           cout << ‘‘Erreur ! Tableau vide !’’ << endl ;
        return -1 ; }

        int res=T[0] ;

        for (int i=1 ; i<T.size() ;i++)
           if (T[i] > res) res=T[i] ;

        return res ;
        }
    e
Proc´dures et fonctions


                                      ee
  Recherche de l’indice du plus grand ´l´ment
    e
Proc´dures et fonctions


                                      ee
  Recherche de l’indice du plus grand ´l´ment


          int RechercheInd(vector<int> T)
        {
        if (T.size()==0) {
           cout << ‘‘Erreur ! Tableau vide !’’ << endl ;
        return -1 ; }

        int res=0 ;

        for (int i=1 ; i<T.size() ;i++)
           if (T[i] > T[res]) res=i ;

        return res ;
        }
    e
Proc´dures et fonctions


      e
  Port´e des identificateurs


                                  e          ea                    e
        Un identificateur XXX peut ˆtre utilis´ ` la ligne l de la d´finition
        d’une fonction F ssi:

                                      e                                e
                XXX est une variable d´finie dans une instruction compos´e
                contenant l.

                                e
                XXX est un param`tre de F .

                                                     e
                (XXX est une variable globale, i.e. d´finie hors de toute
                fonction.)
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;
               return res ; }
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x”
               return res ; }
                                      “y”
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x” 5
               return res ; }
                                      “y”
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x” 5
               return res ; }
                                      “y” 10
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x” 5
               return res ; }
                                      “y” 10
               ...
                                      “z”
               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;
               return res ; }
                                      “a” 10
               ...
                                      “b” 5
               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;
               return res ; }
                                      “a” 10
               ...
                                      “b” 5
               int main() {
               int x,y ;              “res” 5
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;
               return res ; }
                                      “a” 10
               ...
                                      “b” 5
               int main() {
               int x,y ;              “res” 10
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;
               return res ; }
                                      “a” 10
               ...
                                      “b” 5
               int main() {
               int x,y ;              “res” 10
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;     “x” 5
               return res ; }
                                      “y” 10
               ...
                                      “z” 10
               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;       “x” 5
               return res ; }
                                        “y” 10
               ...
                                        “z” 10
               int main() {
                                          ———————————–
               int x,y ;
               x=5 ;                  z = 10
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
    e
Proc´dures et fonctions


Exemple

               int max(int a,int b)
               {int res=b ;
               if (a>b) res = a ;
               return res ; }
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               int z = max(y,x) ;
               cout<<" z = "<<z ; }
               Fin
    e
Proc´dures et fonctions


                  e
  Passage de param`tres par valeur




             e                e                                 e
        Par d´faut, les param`tres d’une fonction sont initialis´s par une
                                    e     e
        copie des valeurs des param`tres r´els.

                                    e
        Modifier la valeur des param`tres formels dans le corps de la
                                                  e      e
        fonction ne change pas la valeur des param`tres r´els.
    e
Proc´dures et fonctions


Essai de permutation

               void permut(int
               a,int b)
               {int aux = b ;
               b = a;
               a = aux ; }
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               permut(y,x) ;
               cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Essai de permutation

               void permut(int
               a,int b)
               {int aux = b ;         “x”
               b = a;
               a = aux ; }            “y”
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               permut(y,x) ;
               cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Essai de permutation

               void permut(int
               a,int b)
               {int aux = b ;         “x” 5
               b = a;
               a = aux ; }            “y”
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               permut(y,x) ;
               cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Essai de permutation

               void permut(int
               a,int b)
               {int aux = b ;         “x” 5
               b = a;
               a = aux ; }            “y” 10
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               permut(y,x) ;
               cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Essai de permutation

               void permut(int
               a,int b)
               {int aux = b ;         “x” 5
               b = a;
               a = aux ; }            “y” 10
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               permut(y,x) ;
               cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Essai de permutation

               void permut(int
               a,int b)
               {int aux = b ;         “x” 5
               b = a;
               a = aux ; }            “y” 10   “a” 10
               ...
                                               “b” 5

               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               permut(y,x) ;
               cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Essai de permutation

               void permut(int
               a,int b)
               {int aux = b ;         “x” 5
               b = a;
               a = aux ; }            “y” 10     “a” 10
               ...
                                                 “b” 5

               int main() {                    “aux”   5
               int x,y ;
               x=5 ;
               y=10 ;
               permut(y,x) ;
               cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Essai de permutation

               void permut(int
               a,int b)
               {int aux = b ;         “x” 5
               b = a;
               a = aux ; }            “y” 10     “a” 10
               ...
                                                 “b” 10

               int main() {                    “aux”   5
               int x,y ;
               x=5 ;
               y=10 ;
               permut(y,x) ;
               cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Essai de permutation

               void permut(int
               a,int b)
               {int aux = b ;         “x” 5
               b = a;
               a = aux ; }            “y” 10     “a” 5
               ...
                                                 “b” 10

               int main() {                    “aux”   5
               int x,y ;
               x=5 ;
               y=10 ;
               permut(y,x) ;
               cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Essai de permutation

               void permut(int
               a,int b)
               {int aux = b ;         “x” 5
               b = a;
               a = aux ; }            “y” 10
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               permut(y,x) ;
               cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Essai de permutation

               void permut(int
               a,int b)
               {int aux = b ;          “x” 5
               b = a;
               a = aux ; }             “y” 10
               ...

                                        ———————————–
               int main() {
               int x,y ;              x=5
               x=5 ;
               y=10 ;
               permut(y,x) ;
               cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Essai de permutation

               void permut(int
               a,int b)
               {int aux = b ;
               b = a;
               a = aux ; }
               ...


               int main() {
               int x,y ;
               x=5 ;
               y=10 ;
               permut(y,x) ;
               cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


                   e          ee
  Passage des param`tres par r´f´rence



                                           e    e
        Pour modifier la valeur d’un param`tre r´el dans une fonction, il
                            e         ee
        faut passer ce param`tre par r´f´rence.

              ee
        Une r´f´rence sur une variable est un synonyme de cette variable,
              a                    e       e           e
        c’est-`-dire une autre mani`re de d´signer le mˆme emplacement
                e
        de la m´moire.

                                         e                 ee
        On utilise le symbole & pour la d´claration d’une r´f´rence:
                               e             e
        Dans la liste des param`tres de la d´finition d’une fonction, type &
        pi d´clare le param`tre pi comme ´tant une r´f´rence sur le i eme
            e               e              e          ee
              e      e
        param`tre r´el vi .
    e
Proc´dures et fonctions


Permutation

           void permut(int & a,int & b)
           {int aux = b ;
           b = a;
           a = aux ; }
           ...


           int main() {
           int x,y ;
           x=5 ;
           y=10 ;
           permut(y,x) ;
           cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Permutation

           void permut(int & a,int & b)
           {int aux = b ;
           b = a;                         “x”
           a = aux ; }
                                          “y”
           ...


           int main() {
           int x,y ;
           x=5 ;
           y=10 ;
           permut(y,x) ;
           cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Permutation

           void permut(int & a,int & b)
           {int aux = b ;
           b = a;                         “x” 5
           a = aux ; }
                                          “y”
           ...


           int main() {
           int x,y ;
           x=5 ;
           y=10 ;
           permut(y,x) ;
           cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Permutation

           void permut(int & a,int & b)
           {int aux = b ;
           b = a;                         “x” 5
           a = aux ; }
                                          “y” 10
           ...


           int main() {
           int x,y ;
           x=5 ;
           y=10 ;
           permut(y,x) ;
           cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Permutation

           void permut(int & a,int & b)
           {int aux = b ;
           b = a;                         “x” 5
           a = aux ; }
                                          “y” 10
           ...


           int main() {
           int x,y ;
           x=5 ;
           y=10 ;
           permut(y,x) ;
           cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Permutation

           void permut(int & a,int & b)
           {int aux = b ;
           b = a;                         “b” “x” 5
           a = aux ; }
                                          “a” “y” 10
           ...


           int main() {
           int x,y ;
           x=5 ;
           y=10 ;
           permut(y,x) ;
           cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Permutation

           void permut(int & a,int & b)
           {int aux = b ;
           b = a;                         “b” “x” 5
           a = aux ; }
                                          “a” “y” 10
           ...


           int main() {
           int x,y ;                                   “ aux ” 5
           x=5 ;
           y=10 ;
           permut(y,x) ;
           cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Permutation

           void permut(int & a,int & b)
           {int aux = b ;
           b = a;                         “b” “x” 10
           a = aux ; }
                                          “a” “y” 10
           ...


           int main() {
           int x,y ;                                   “ aux ” 5
           x=5 ;
           y=10 ;
           permut(y,x) ;
           cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Permutation

           void permut(int & a,int & b)
           {int aux = b ;
           b = a;                         “b” “x” 10
           a = aux ; }
                                          “a” “y” 5
           ...


           int main() {
           int x,y ;                                   “ aux ” 5
           x=5 ;
           y=10 ;
           permut(y,x) ;
           cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Permutation

           void permut(int & a,int & b)
           {int aux = b ;
           b = a;                         “x” 10
           a = aux ; }
                                          “y” 5
           ...


           int main() {
           int x,y ;
           x=5 ;
           y=10 ;
           permut(y,x) ;
           cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Permutation

           void permut(int & a,int & b)
           {int aux = b ;
           b = a;                           “x” 10
           a = aux ; }
                                            “y” 5
           ...


           int main() {
                                              ———————————
           int x,y ;
           x=5 ;                          x = 10
           y=10 ;
           permut(y,x) ;
           cout<<" x = "<<x ; }
    e
Proc´dures et fonctions


Permutation

           void permut(int & a,int & b)
           {int aux = b ;
           b = a;
           a = aux ; }
           ...


           int main() {
           int x,y ;
           x=5 ;
           y=10 ;
           permut(y,x) ;
           cout<<" x = "<<x ; }
           Fin
    e
Proc´dures et fonctions


               ee
  Passage par r´f´rence



                                     e      e
                Il faut que les param`tres r´els soient compatibles avec un
                              ee
                passage par r´f´rence. . .
                permut(x,5) n’est pas possible !

                                     ee                               e
                Usage “bizarre” des r´f´rences dans la liste des param`tres:
                const type & p
                   e                   ee
                Id´e: le passage par r´f´rence est plus efficace que le passage
                                  e
                par valeur car il ´vite la recopie des arguments car seule
                            e                                     e a
                l’adresse m´moire de l’argument est communiqu´e ` la
                fonction.
    e
Proc´dures et fonctions


Exercice . . .



        Algorithmes de tri
        Comment trier un tableau d’entiers ?
    e
Proc´dures et fonctions


Exercice . . .



        Algorithmes de tri
        Comment trier un tableau d’entiers ?
                                         ee                   a
                rechercher le plus grand ´l´ment et le placer ` la fin du tableau
                                  e
                recherche le deuxi`me plus grand et le placer en
                           e
                avant-derni`re position
                etc.
    e
Proc´dures et fonctions


Exercice . . .


        Algorithmes de tri
        Comment trier un tableau d’entiers Tab ?
        Pour IndFin = Tab.size()-1 ... 1 faire
                                                       ee
                rechercher l’indice IMAX du plus grand ´l´ment de Tab entre
                              a
                les indices 0 ` IndFin.
                             ee           e
                Permuter les ´l´ments plac´s en IMAX et IndFin.
    e
Proc´dures et fonctions


Exercice . . .


        Algorithmes de tri
        Comment trier un tableau d’entiers Tab ?
        Pour IndFin = Tab.size()-1 ... 1 faire
                                                       ee
                rechercher l’indice IMAX du plus grand ´l´ment de Tab entre
                              a
                les indices 0 ` IndFin.
                             ee           e
                Permuter les ´l´ments plac´s en IMAX et IndFin.

                   e e            e                        ee
        A la premi`re ´tape, on s´lectionne le plus grand ´l´ment et on le
              a                                           e
        place ` la fin du tableau ; puis on trouve le deuxi`me plus grand et
                    a              e
        on le place ` l’avant-derni`re place etc.
    e
Proc´dures et fonctions


               e
  Fonction de s´lection

            int RechercheInd(vector<int> T, int imax)
        {
            if (T.size() < imax-1) {
             cout << "Erreur ! Tableau trop petit ! " << endl ;
             return -1 ; }

            int res=0 ;

            for (int i=1 ; i<= imax ;i++)
             if (T[i] > T[res]) res=i ;

            return res ;
        }
    e
Proc´dures et fonctions


               e
  Fonction de s´lection


            vector<int> Trier(vector<int> T)
        {
            vector<int> Taux = T ;
            int aux ;

            for (int i=Taux.size()-1 ; i>0 ; i--) {
              aux = RechercheInd(Taux,i) ;
              Permuter(Taux[aux],Taux[i]) ;
             }

            return Taux ;
        }
    e
Proc´dures et fonctions


               e
  Fonction de s´lection


                                      ee
        Tri in situ avec passage par r´f´rence
         void Trier(vector<int> & T)
    e
Proc´dures et fonctions


               e
  Fonction de s´lection


                                      ee
        Tri in situ avec passage par r´f´rence
          void Trier(vector<int> & T)
        {
           int aux ;

            for (int i=T.size()-1 ; i>0 ; i--) {
              aux = RechercheInd(Taux,i) ;
              Permuter(T[aux],T[i]) ;
             }
        }
 e        e
R´cursivit´


Plan
       2      Types, variables...
       3      Expressions
       4      Instructions
       5          e
              Entr´es - Sorties
       6      Exemples
       7      Evaluation des expressions
       8                 e e
              Structure g´n´rale d’un programme C++
       9          e
              Proc´dures et fonctions
      10       e        e
              R´cursivit´
      11           e
              Compl´ments sur les fonctions
      12          e            e     e
              Port´e, visibilit´, dur´e de vie des variables
      13           e
              Compl´ments
 e        e
R´cursivit´


           e
Fonctions r´cursives



        La factorielle...
            int fact(int n)
        {
              assert(n>=0) ;
              if (n==0) return 1 ;
              return n*fact(n-1) ;
        }
 e        e
R´cursivit´


Les tours de Hanoi


            void Hanoi(int nb,int p1, int p2)
        {

        if (nb > 0) {
          int p3 = 6-p1-p2 ;
          Hanoi(nb-1,p1,p3) ;
          cout << "On bouge le Pion " << nb << " vers " <<
        p2 ;
          Hanoi(nb-1,p3,p2) ;
        }
        }
     e
Compl´ments sur les fonctions


Plan
      2    Types, variables...
      3    Expressions
      4    Instructions
      5        e
           Entr´es - Sorties
      6    Exemples
      7    Evaluation des expressions
      8               e e
           Structure g´n´rale d’un programme C++
      9        e
           Proc´dures et fonctions
     10     e        e
           R´cursivit´
     11         e
           Compl´ments sur les fonctions
     12        e            e     e
           Port´e, visibilit´, dur´e de vie des variables
     13         e
           Compl´ments
     e
Compl´ments sur les fonctions


             e              e
Valeurs par d´faut des param`tres



                                          e              e
       On peut attribuer des valeurs par d´faut aux param`tres d’une
       fonction.
         int max(int a,int b =0)
       {
       if (a>b) return a ;
       else return b ;
       }
     e
Compl´ments sur les fonctions


Recherche dichotomique

         int RechDicho(vector<double> Tab,int bg, int
       bd,double x)
       { if (bg > bd) return -1 ;
       int M = (bg+bd)/2 ;
       if (Tab[M]==x) return M ;
       if (Tab[M] > x)
         return RechDicho(Tab,bg,M-1,x) ;
       else return RechDicho(Tab,M+1,bd,x) ;
       }
         int Recherche(vector<double> Tab,double x)
       { int taille = Tab.size() ;
       if (taille == 0) return -1 ;
       return RechDicho(Tab,0,taille-1,x) ;
       }
     e
Compl´ments sur les fonctions


Recherche dichotomique


         int Recherche(vector<double> Tab, double x,
       int bg =-1, int bd =-1)
       { if((bg==-1)&&(bd ==-1))
         return Recherche(Tab,x,0,Tab.size()-1) ;
       if (bg > bd) return -1 ;
       int M = (bg+bd)/2 ;
       if (Tab[M]==x) return M ;
       if (Tab[M] > x)
         return Recherche(Tab,x,bg,M-1) ;
       else return Recherche(Tab,x,M+1,bd) ;
       }
       Appel directement avec: Recherche(T,10.3)
     e
Compl´ments sur les fonctions


Fonctions inline


                                          e
       Pour de petites fonctions, il peut ˆtre plus efficace (= rapide)
         e                              a
       d’´viter un appel de fonction et ` la place, expanser le corps de la
       fonction en lieu et place de chaque appel.
                                    e
       C’est possible avec le mot cl´ inline.
         inline int max(int a,int b =0)
       {
       if (a>b) return a ;
       else return b ;
       }
     e
Compl´ments sur les fonctions


Le tri fusion




       Principe:
       Pour trier un tableau T entre les indices a et b:
                                      a+b
               On trie entre a et      2
                                a+b
               On trie entre     2    et b
                                          ea                             e
               On construit un tableau tri´ ` partir des sous-parties tri´es.
    e            e     e
Port´e, visibilit´, dur´e de vie des variables

          void Tri fusion(vector<int> & T,int bg =-1, int bd
        =-1)
        {
          if ((bg==-1) && (bd==-1)) {
            bg=0 ;
            bd=int(T.size()) -1 ;
          }
          int k ;
          if (bg < bd) {
            k = (bg+bd)/2 ;
            Tri fusion(T,bg,k) ;
            Tri fusion(T,k+1,bd) ;
            Fusion(T,bg,k,bd) ;
          }
    e            e     e
Port´e, visibilit´, dur´e de vie des variables

        }

Plan
       2     Types, variables...
       3     Expressions
       4     Instructions
       5         e
             Entr´es - Sorties
       6     Exemples
       7     Evaluation des expressions
       8                e e
             Structure g´n´rale d’un programme C++
       9         e
             Proc´dures et fonctions
      10      e        e
             R´cursivit´
      11          e
             Compl´ments sur les fonctions
      12         e            e     e
             Port´e, visibilit´, dur´e de vie des variables
      13          e
             Compl´ments
    e            e     e
Port´e, visibilit´, dur´e de vie des variables


    e
Port´e d’un identificateur


                e
        La port´e d’un identificateur correspond aux parties du programme
         u                        e          e                         a
        o` cet identificateur peut ˆtre utilis´ sans provoquer d’erreur ` la
        compilation.
               e                                                       e
        La port´e d’une variable globale ou d’une fonction globale est ´gale
        au programme.
        La port´e d’une variable locale va de sa d´finition jusqu’` la fin de
               e                                  e              a
                e                      e                          e
        la premi`re instruction compos´e ({...}) qui contient sa d´finition.
                                          e
        Deux variables peuvent avoir le mˆme nom mais dans ce cas, elle
                               e     e
        doivent avoir deux port´s diff´rentes.
    e            e     e
Port´e, visibilit´, dur´e de vie des variables


    e
Port´e


          {
        int i=3 ;
           {
             int i=5 ;
             cout << i ; // affiche 5
           }
        cout << i ; // affiche 3
        }

                                       e      e
        Les deux variables ont des port´es diff´rentes !

        Exemple. . .
    e            e     e
Port´e, visibilit´, dur´e de vie des variables


         e
Visibilit´



                      e
        • La visibilit´ d’une variable dit quand elle est accessible
                    e                        e
        La visibilit´ est inclue dans la port´e...

                 e                                  a     e
        • La dur´e de vie d’une variable correspond ` la p´riode depuis
          e      a
        cr´ation ` sa destruction.
           e                e    ıncident pour toutes les variables que
        Dur´e de vie et port´e co¨
                   e     e
        nous avons ´voqu´es jusqu’ici.
        mais . . .
    e            e     e
Port´e, visibilit´, dur´e de vie des variables


Variables static

                   e                               e e                  e
        L’espace m´moire d’une variable locale d´clar´e static est allou´
                                 e         a
        une seule fois et n’est d´truit qu’` la fin du programme !
          void Test(int v)
        {
        static int compteur=0 ;

        compteur++ ;
        cout << compteur << "-eme appel de Test"<< endl ;

        cout << " v = " << v << endl ;

        }
              e
        Sa dur´e de vie est celle du programme.
    e            e     e
Port´e, visibilit´, dur´e de vie des variables


Hanoi (suite)
                                        a        e
        Obj: compter le nombre d’appels ` la proc´dure Hanoi.
         void Hanoi(int nb,int p1, int p2, int affichage=0)
        { static int NB = 0 ;
        NB++ ;
        if (affichage == 1) {
        cout << NB << " appels de Hanoi "
        return ; }

        if (nb > 0) {
          int p3 = 6-p1-p2 ;
          Hanoi(nb-1,p1,p3) ;
          cout << "On bouge le Pion " << nb << " vers le
        piquet " << p2 << endl ;
          Hanoi(nb-1,p3,p2) ;
        }
        }
    e            e     e
Port´e, visibilit´, dur´e de vie des variables


Espace de noms
                                                                e
        Un programme important utilise de nombreuses biblioth`ques,
                             e              e
        fonctions etc. Pour ´viter les probl`mes de conflit de noms, on
        utilise des espaces de noms (namespace) :
                                   a
                 on associe un nom ` un ensemble de variables, types,
                 fonctions.
                 leur nom complet est: leur nom d’espace suivi de :: et de leur
                 nom.
                                                 e
                 Ex. la fonction int fct(){...} d´finie dans le domaine A
                 aura pour nom complet A::fct()

        Les noms complets de cout et cin sont std::cout et
        std::cin.

             e        e
        Pour ´viter d’´crire les noms complets , on utilise:
        using namespace std ;
    e            e     e
Port´e, visibilit´, dur´e de vie des variables


  e
Cr´er un espace de nom


            namespace toto {

            int N = 10 ;

            int Test()
            {
              cout << "test... " ;
            }

        }
        Les objets N et Test ont pour nom toto::N et toto::Test
     e
Compl´ments


Plan
     2    Types, variables...
     3    Expressions
     4    Instructions
     5        e
          Entr´es - Sorties
     6    Exemples
     7    Evaluation des expressions
     8               e e
          Structure g´n´rale d’un programme C++
     9        e
          Proc´dures et fonctions
     10    e        e
          R´cursivit´
     11        e
          Compl´ments sur les fonctions
     12       e            e     e
          Port´e, visibilit´, dur´e de vie des variables
     13        e
          Compl´ments
     e
Compl´ments


     e
Compl´ments - 1

                        e
      Instructions suppl´mentaires:
                                  e             e
              break provoque l’arrˆt de la premi`re instruction do, for,
              switch ou while englobant.
              continue provoque (dans une instruction do, for, ou while)
                    e        e                                  e
              l’arrˆt de l’it´ration courante et le passage au d´but de
                  e
              l’it´ration suivante.
              switch (exp) {
              case cste1 : liste d’instructions1
              ...
              case csten : liste d’instructionsn
              default: liste d’instructions
              }
     e
Compl´ments


     e
Compl´ments - 2


                                                        e    e a
               (exp) ? exp1 : exp2 vaut exp1 si exp est ´valu´e ` vrai et
              exp2 sinon.
              m = (i < j) ? i : j
                         e
          var op = expr d´signe l’expression var = var op expr
          (op ∈ {+,-,*,/,%})
      int i=2,j=34 ;                     int i=2,j=34 ;
      i += 2 ;                           i = i+2 ;
      j *= 10 ;                          j = j*10 ;
      j *= (i++) ;                       j = j*i ;
                                         i = i+1 ;
     e
Compl´ments


     e
Compl´ments - 2


                                                        e    e a
               (exp) ? exp1 : exp2 vaut exp1 si exp est ´valu´e ` vrai et
              exp2 sinon.
              m = (i < j) ? i : j
                           e
          var op = expr d´signe l’expression var = var op expr
          (op ∈ {+,-,*,/,%})
      int i=2,j=34 ;                     int i=2,j=34 ;
      i += 2 ;                           i = i+2 ;
      j *= 10 ;                          j = j*10 ;
      j *= (i++) ;                       j = j*i ;
                                         i = i+1 ;
          A la fin, on a: i==5 et j==1360
      e
Troisi`me partie III

   Classes C++
Introduction


Plan


      14       Introduction

      15                           e
               Regroupement de donn´es

      16       Classes C++
                              e
                 Champs et m´thodes
                 Constructeurs et destructeurs
                 Fonctions amies
                 Conversions entre types

      17                     e
               Surcharge d’op´rateurs
Introduction


Introduction



        Un algorithme n’utilise pas que des objets de type int, double ou
        bool...
               e
               ´tats et transitions lorsqu’on parle de graphes.
               Piquet et pions pour Hanoi
               Fractions
               Piles
                                   a
        Un programme doit “coller” ` l’algorithme !
Introduction


De nouveaux types




                         e                                e
        Il faut pouvoir d´finir de nouveaux types de donn´es.
           e
        D´finir des variables de ce types, les manipuler dans les fonctions
        etc.
Introduction


De nouveaux types




                         e                                e
        Il faut pouvoir d´finir de nouveaux types de donn´es.
           e
        D´finir des variables de ce types, les manipuler dans les fonctions
        etc.

                       e                         e           e
        Un type de donn´es = regroupement de donn´es + des op´rations

        Comme les types de base !
                    e
Regroupement de donn´es


Plan


     14   Introduction

     15                       e
          Regroupement de donn´es

     16   Classes C++
                         e
            Champs et m´thodes
            Constructeurs et destructeurs
            Fonctions amies
            Conversions entre types

     17                 e
          Surcharge d’op´rateurs
                    e
Regroupement de donn´es


                    e
Regroupement de donn´es



                                e                      e
       Exemple: une base de donn´es pour les notes des ´tudiants.
                    e
Regroupement de donn´es


                    e
Regroupement de donn´es



                                e                      e
       Exemple: une base de donn´es pour les notes des ´tudiants.

                     e
       Chaque fiche d’´tudiant contient :
                             e
              un nom et un pr´nom
                    e
              un num´ro d’inscription
              un ensemble de notes

                        e
       Une “base de donn´es” pour une promo = un ensemble de fiches
                    e
Regroupement de donn´es


        e
Fiche d’´tudiants. . .


        e
       D´finir le type fiche:

       struct FicheEtudiant {
          s t r i n g Nom ;
          s t r i n g Prenom ;
          i n t Numero ;
          v e c t o r <d o u b l e > N o t e s ;
       };


                          e
       Ce n’est pas ordonn´...
                    e
Regroupement de donn´es


        e
Fiche d’´tudiants. . .



              e        e
       Autre d´finition ´quivalente pour le type fiche:


       struct FicheEtudiant {
          s t r i n g Nom, Prenom ;
          i n t Numero ;
          v e c t o r <d o u b l e > N o t e s ;
       };
                    e
Regroupement de donn´es


Utilisation des fiches


       fiche est un type comme les autres:
       fiche F ;
        e
       d´finit une variable F de type fiche.
                                                             e
       Une fiche contient plusieurs parties (champs), on y acc`de par leur
       nom pr´c´d´ d’un point “.” :
             e e e
               e
       F.Nom d´signe le champ (de type string) Nom de la fiche F.
                    e
       F.Notes[i] d´signe le champ (de type double) Notes[i] de la
       fiche F.
       etc.
                    e
Regroupement de donn´es


Utilisation des fiches



        e
       D´finir les champs d’une fiche:

       FicheEtudiant F;
       F . Nom = ” T a k i s ” ;
       F . Prenom = ” Jean ” ;
       F . Numero = 1 2 3 4 ;

       F . Notes [ 2 ] = 12.3 ;
                    e
Regroupement de donn´es


Utilisation des fiches


       Une fonction afficher...


       void Afficher ( FicheEtudiant v)
       {
         c o u t << ”No : ” << v . Numero << ” − ” <<                  v . Prenom << ”
         f o r ( i n t i =0; i < v . N o t e s . s i z e ( ) ; i ++)
             c o u t << v . N o t e s [ i ] << ” ” ;
         c o u t << e n d l ;
       }

       demo 1-2-3
                    e
Regroupement de donn´es


Les “struct”




                           e
       On utilise le type d´fini pat un struct comme n’importe quel
                                            e        e
       autre type: dans les fonctions (param`tre ou r´sultat), les variables,
       les tableaux etc.

                             e
       Les affectations (param`tres de fonction, variable, etc.) se font
              a
       champ ` champ.
Classes C++


Plan


     14   Introduction

     15                       e
          Regroupement de donn´es

     16   Classes C++
                         e
            Champs et m´thodes
            Constructeurs et destructeurs
            Fonctions amies
            Conversions entre types

     17                 e
          Surcharge d’op´rateurs
Classes C++


Les classes C++


                  e                       e
      Lorsqu’on d´finit un type de donn´es, on fournit des fonctions de
                                                 e         e
      manipulation et impose leur usage: les d´tails d’impl´mentation
                ae
      n’ont pas ` ˆtre connus par l’utilisateur.

                                              e                  e
      On veut donc offrir une interface et prot´ger certaines donn´es.

      Les classes permettent de
                                e
              regrouper des donn´es
              associer des fonctions aux objets de la classe
                               e a                e
              restreindre l’acc`s ` certaines donn´es
Classes C++


          e
Fichier d’´tudiants

                                          e
      On veut construire des bases de donn´es pour stocker les fiches
        e
      d’´tudiants de chaque promo.
      Pour chaque promo, on veut disposer des fonctions suivantes:
                                  e          e        e
              saisir les noms, pr´noms et num´ros des ´tudiants :
              (initialisation de la base)
                                       e
              saisir des notes pour un ´tudiant
                                    e
              afficher les notes d’un ´tudiant
                                     e
              afficher la moyenne d’un ´tudiant
              afficher la moyenne pour un cours
                                 e e
              afficher la moyenne g´n´rale
Classes C++


          e
Fichier d’´tudiants

                                          e
      On veut construire des bases de donn´es pour stocker les fiches
        e
      d’´tudiants de chaque promo.
      Pour chaque promo, on veut disposer des fonctions suivantes:
                                  e          e        e
              saisir les noms, pr´noms et num´ros des ´tudiants :
              (initialisation de la base)
                                       e
              saisir des notes pour un ´tudiant
                                    e
              afficher les notes d’un ´tudiant
                                     e
              afficher la moyenne d’un ´tudiant
              afficher la moyenne pour un cours
                                 e e
              afficher la moyenne g´n´rale

      Et c’est tout !
Classes C++


          e
Fichier d’´tudiants




                                         e
      Chaque promo doit contenir les donn´es suivantes:
                          e
              le nombre d’´tudiants
              le nombre de cours
              la liste des cours
                                e
              la fiche de chaque ´tudiant
Classes C++


          e
Fichier d’´tudiants


            e                 e
      On int`gre donc les donn´es suivantes dans une promo:


       c l a s s Promo {
         private :
           i n t Nbc ;
           i n t Nbe ;
           v e c t o r <s t r i n g > C o u r s ;
           v e c t o r <F i c h e E t u d i a n t > E t u d i a n t s ;

       ...

       };
Classes C++


         e                         e
Comment d´finir les fonctions associ´es


                                                    e    e
      On va utiliser une autre approche que celle pr´sent´e dans la partie
      A.
                          e
              On va prot´ger certains aspects du type Promo: la structure
              interne, le nom des champs...
                      e                           e
              On va d´finir des fonctions particuli`res (fonctions membre,
                e                               e     a             e
              m´thodes) qui seules pourront acc´der ` la partie cach´e du
              type Promo.

            e
      Ces m´thodes seront l’interface de la classe.
              e
      On les d´finit dans la classe.
Classes C++


 e
M´thode - fonction membre

                                          a
      Ces fonctions s’appliquent toujours ` un objet de la classe, plus
      e               a               e
      ´ventuellement ` d’autres param`tres.
                         o
      Cet objet joue un rˆle particulier: on dit que l’on appelle la
      m´thode sur lui.
       e
           e
      Le m´canisme d’appel de ces fonctions tient compte de cette
         e          e                               e
      diff´rence et s´pare cet objet des autres param`tres:
          o
      Plutˆt que de faire Test(o,p1,...,pk), on fait:

                              o.Test(p1,...,pk)

      On appelle Test comme un champ...
                  c
      Vision: o re¸oit le “message” ou l’ “ordre” Test.
Classes C++


 e
M´thode - fonction membre


                   e             e e
              Les m´thodes sont d´clar´es dans la classe.
                                    e
              Le nom complet de la m´thode Test de la classe Toto est
              Toto::Test
                    e                      e
              Les m´thodes peuvent acc´der aux champs des objets de la
                                         a
              classe: ce sont les seules ` pouvoir le faire (ou presque) !
                                                e            ıt
              L’objet sur lequel elle sont appel´es, n’apparaˆ explicitement
                       e                e
              dans la d´finition des m´thodes.
                   e                                        e
              Par d´faut, les champs apparaissant dans la d´finition d’une
                e
              m´thode sont ceux de l’objet sur lequel la fonction sera
                   e
              appel´e.
Classes C++


Initialisation
       c l a s s Promo {
         private :
           i n t Nbc ;
           i n t Nbe ;
           v e c t o r <s t r i n g > C o u r s ;
           v e c t o r <F i c h e E t u d i a n t > E t u d i a n t s ;

        public :
          void I n i t i a l i s a t i o n ( ) ;
          void SaisieNotes ( int n ) ;
          void AfficheNotesE ( i n t n ) ;
          d o u b l e MoyenneE ( i n t n ) ;
          d o u b l e MoyenneC ( i n t c ) ;
          d o u b l e MoyenneG ( ) ;
       };
Classes C++


Initialisation
       v o i d Promo : : I n i t i a l i s a t i o n ( )
       {
           c o u t << ”Nb d ’ e t u d i a n t s : ” ;               c i n >> Nbe ;
           c o u t << ”Nb de c o u r s : ” ;                  c i n >> Nbc ;
          C o u r s = v e c t o r <s t r i n g >(Nbc ) ;
           E t u d i a n t s = v e c t o r <F i c h e E t u d i a n t >(Nbe ) ;

              f o r ( i n t i =0; i < Nbc ; i ++) {
                  c o u t << ” C o u r s ”<< i << ” : ” ;
                  c i n >> C o u r s [ i ] ; }

              f o r ( i n t i =0; i <Nbe ; i ++) {
                  c o u t << ”Nom : ” ;            c i n >> E t u d i a n t s [ i ] . Nom ;
                  c o u t << ” Prenom : ” ;            c i n >> E t u d i a n t s [ i ] . Prenom ;
                  c o u t << ”Numero : ” ;             c i n >> E t u d i a n t s [ i ] . Numero ;

                 E t u d i a n t s [ i ] . N o t e s = v e c t o r <d o u b l e >(Nbc ) ;
           }
       }
Classes C++


Constructeurs


                e               e          e                  a
              M´thodes particuli`res appel´es automatiquement ` chaque
               e
              d´finition d’un objet de la classe.
                                          a
              Pour passer des arguments ` un constructeur, il suffit de faire
              suivre le nom de la variable par la liste des arguments :
              MaClasse A(i,f) ;
                                                  e
              Lorsqu’aucun argument n’est donn´, le constructeur sans
                                 e
              argument est appel´.
                                           e
              Si aucun constructeur n’est d´fini explicitement, le
                            e
              compilateur cr´e un constructeur sans argument
              MaClasse::MaClasse() qui se contente d’appeler les
              constructeurs (sans argument) de chaque champ de l’objet.
Classes C++


Constructeur copieur


      MaClasse (const MaClasse &)
              e                          e
      : utilis´ pour le passage des param`tres et les initialisations.
                                            e
              Si une fonction a un param`tre A du type MaClasse, un appel
                                                                        a
              de cette fonction avec une variable V de MaClasse conduit `
              l’initialisation de A avec V via le constructeur copieur.
                          e                                         a
              Lorsqu’on d´finit une variable V et qu’on l’initialise ` une
              valeur E, par l’instruction “MaClasse V=E ;”, on utilise le
              constructeur copieur.
                  e
              Diff´rence avec : “MaClasse V ;       V=E ;”
                                ee      e
      Le constructeur copieur cr´´ par d´faut fait une initialisation
             a
      champ ` champ avec les champs de l’argument.
Classes C++


Constructeur / destructeur



                                                  e
      Il existe aussi des destructeurs : on peut d´finir un (et un seul)
                                 e
      destructeur qui est appel´ automatiquement lorsqu’une variable
                   e
      locale est d´truite
                                                  e
      (surtout utiles pour les structures de donn´es dynamiques)

                                e
      Pour comprendre tous ces m´canismes d’appel...
      il faut les essayer !!

                                                      cf. Constructeurs.cc
Classes C++


Fonctions amies

      Si une fonction F est “amie” (friend) d’une classe C1, alors F
               e                   e
      peut acc´der aux champs priv´s de C1.
      Si une classe C2 comme est “amie” de C1, toutes les fonctions
                                e                   e
      membres de C2 peuvent acc´der aux champs priv´s de C1.
           e                            e
      Ces d´clarations se font dans la d´finition de C1 :

       c l a s s C1 {
              ...
           f r i e n d t y p e −de−F F ( param−de−F ) ;
           f r i e n d c l a s s C2 ;
              ...
       };
Classes C++


Conversions entre types
                                             e
      Comme pour les types simples, on peut d´finir des conversions
      entre les classes.
                                                              e
              Un constructeur de T1 qui prend un unique param`tre de type
                   e
              T2 d´finit implicitement une conversion de T2 dans T1.
              (pas de composition: ne marche que pour des conversions en
                   e
              une ´tape)
              Une fonction membre operator T1() dans la classe T2
               e
              d´finit aussi une conversion de T2 dans T1.
               e                    e
              (´vite de modifier la d´finition de T1)
      Par exemple :
       class fraction {
       public :
          ...
          fraction ( int v)              {num=v ; den =1;}
          d o u b l e ( ) { r e t u r n d o u b l e (num) / den ; }
       };
              e
Surcharge d’op´rateurs


Plan


     14    Introduction

     15                        e
           Regroupement de donn´es

     16    Classes C++
                          e
             Champs et m´thodes
             Constructeurs et destructeurs
             Fonctions amies
             Conversions entre types

     17                  e
           Surcharge d’op´rateurs
              e
Surcharge d’op´rateurs


              e
Surcharge d’op´rateurs

                                               e
       Il est possible de surcharger les op´rateurs de C++ (+, -, [ ], =,
                            e                e
       ==, . . . ): les arit´s et les priorit´s ne changent pas.
       Deux points de vue:
               fonction globale: “A op B” est vue comme l’application d’une
                             a
               fonction “op” ` deux arguments “A” de type TA et “B” de
               type TB.
                f r a c t i o n o p e r a t o r ∗( f r a c t i o n f , f r a c t i o n g )
                { r e t u r n f r a c t i o n ( f . Numerateur ( ) ∗ g . Numerateur ( ) ,
                                  f . Denominateur ( ) ∗ g . Denominateur ( ) ) ; }

                f r a c t i o n o p e r a t o r −( f r a c t i o n f )
                { r e t u r n f r a c t i o n (− f . Numerateur ( ) ,
                                                 f . Denominateur ( ) ) ; }
              e
Surcharge d’op´rateurs


              e
Surcharge d’op´rateurs
               fonction membre: “A op B” est vue comme l’application d’une
                             a
               fonction “op” ` un argument “B” de type TB sur l’objet “A”
               de type TA.
                class fraction {
                private :
                   i n t num , den ;
                public :
                   ...
                   f r a c t i o n o p e r a t o r −();
                   f r a c t i o n o p e r a t o r ∗( f r a c t i o n h ) ;
                };

                f r a c t i o n f r a c t i o n : : o p e r a t o r −()
                    { r e t u r n f r a c t i o n (−num , den ) ; }

                f r a c t i o n f r a c t i o n : : o p e r a t o r ∗( f r a c t i o n h )
                    { r e t u r n f r a c t i o n (num∗h . num , den ∗h . den ) ; }
              e
Surcharge d’op´rateurs


Surcharge de cout <<


           e                  e            e            e
       L’op´rateur << ne peut ˆtre surcharg´ que de mani`re globale.
       Profil pour un type T:
       ostream & << (ostream & , T )
       Exemple:
       //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
       o s t r e a m & o p e r a t o r <<(o s t r e a m & os , f r a c t i o n f )
       {
       o s << f . Numerateur ( ) << ”/” << f . D e n o m i n a t e u r ( ) ;
        r e t u r n os ;
       }
       //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
            e
      Quatri`me partie IV

                  e
Structures de donn´es dynamiques
Pointeurs


Plan


     18     Pointeurs


     19     Pointeurs et tableaux


     20     new et delete


     21                       e
            structures de donn´es dynamiques


     22     Retour sur les classes
Pointeurs


Pointeurs




                               e
       Une variable permet de d´signer – par un nom – un emplacement
                e
       dans la m´moire.

                                 e                              e
       Il est aussi possible de d´signer directement les cases m´moire par
       leur adresse.

                                                   e
       Un pointeur permet de stocker ces adresses m´moire.
Pointeurs


Pointeurs, *, &
                               e
            Un pointeur est typ´ : on distingue les pointeurs sur un int,
            sur un double, sur une fraction etc.
              e
            D´finir un pointeur:
            type * nom ;
            nom est un pointeur sur type, i.e. pouvant recevoir une
                     e
            adresse d´signant un objet de type type.
                   e                 e
            &V repr´sente l’adresse m´moire d’une variable V.
                e                   e
            *P d´signe l’objet point´ par le pointeur P.

        i n t i , ∗ pi , k ;
        i =3;
        p i = &i ;           // p i p o i n t e s u r i
        k = ( ∗ p i )+5;                          a
                             // i d e n t i q u e ` :    k=i +5
        ( ∗ p i ) = k +2;                         a
                             // i d e n t i q u e ` :   i = k+2
        ( ∗ p i )++;
        // i c i , i =11 , k=8
Pointeurs


              ee
Pointeurs et r´f´rences


                                ee
       Au lieu du passage par r´f´rence, il est possible de passer (par
       valeur) les adresses des arguments d’une fonction et de modifier les
            e              a                      e
       donn´es contenues ` ces adresses via l’op´rateur *.
       Fonction permut :
        v o i d permut ( i n t ∗ pa , i n t ∗ pb )
        { i n t aux = ( ∗ pa ) ;
        ( ∗ pa ) = ( ∗ pb ) ;
        ( ∗ pb ) = aux ; }
             e                                 e
       Pour ´changer les valeurs de i et j, on ´crit permut(&i,&j) ;
       (seule solution en C)
Pointeurs et tableaux


Plan


      18    Pointeurs


      19    Pointeurs et tableaux


      20    new et delete


      21                      e
            structures de donn´es dynamiques


      22    Retour sur les classes
Pointeurs et tableaux


         a
Tableaux ` la “C”

        type nom[taille] ;
             e                   ee
        → d´finit un tableau d’´l´ments de type type et de taille taille
                      a                ee                      e    e
        (indices de 0 ` taille − 1). L’´l´ment d’indice i est d´sign´ par
        nom[i].
                                   e                          e
        Dans “int Tab[10]”, Tab d´signe l’adresse de la premi`re case
        du tableau (i.e. &Tab[0]) et le type de Tab est “const int *”.
        Qu’est-ce que Tab[i] ?
Pointeurs et tableaux


         a
Tableaux ` la “C”

        type nom[taille] ;
             e                   ee
        → d´finit un tableau d’´l´ments de type type et de taille taille
                      a                ee                      e    e
        (indices de 0 ` taille − 1). L’´l´ment d’indice i est d´sign´ par
        nom[i].
                                   e                          e
        Dans “int Tab[10]”, Tab d´signe l’adresse de la premi`re case
        du tableau (i.e. &Tab[0]) et le type de Tab est “const int *”.
        Qu’est-ce que Tab[i] ? c’est (*(Tab+i)).
        int T[10];
        int ∗ p;
        p = &T [ 4 ] ;
        p [ 0 ] = 100;   //    e               a
                               ´ q u i v a u t ` T [ 4 ] = 100
        p [ 1 ] = 200;   //    e               a
                               ´ q u i v a u t ` T [ 5 ] = 100
Pointeurs et tableaux


Pointeurs et tableaux


                                                 e
                Passer un tableau “C” en param`tre d’une fonction revient `a
                                            e                       ee
                passer l’adresse de la premi`re case ⇒ passage par r´f´rence.
                        e             e
                Pour d´clarer un param`tre T de type tableau d’entiers, on
                e
                ´crit: int T[].
                               e        e                     e
                La taille doit ˆtre pass´e avec un autre param`tre.
                void Tri(int T[],int taille)
                autres chaˆ                e                                  e
                             ınes de caract`res : tableaux (simples) de caract`res
                                             e      e
                se terminant par le caract`re sp´cial ’\0’.
                char T[8] = "exemple" ;
                  e
                d´finit et initialise le tableau T avec T[0]= ’e’, T[1]=’x’,
                . . . , T[7]=’\0’.
new et delete


Plan


     18    Pointeurs


     19    Pointeurs et tableaux


     20    new et delete


     21                      e
           structures de donn´es dynamiques


     22    Retour sur les classes
new et delete


new et delete


                         e                e            e             e
       obj : allouer et d´sallouer de la m´moire sans d´pendre la dur´e de
       vie des variables.
                                                 e
                “new type ;” alloue un espace m´moire pour contenir un objet
                                                                  e
                de type type et retourne l’adresse ce cette zone m´moire.
                                                      e
                “P = new type[N] ;” alloue un espace m´moire capable de
                contenir N objets de type type ...
                              e                  e
                “delete P ;” d´salloue l’espace m´moire d’adresse P.
                (ou “delete [ ] P ;”)
                     e                 e      e
       Une zone allou´e par new n’est d´sallou´e que par l’appel de
       delete. . .
new et delete




                    e
       Un peu de cin´ma ...
                  e
structures de donn´es dynamiques


Plan


     18    Pointeurs


     19    Pointeurs et tableaux


     20    new et delete


     21                      e
           structures de donn´es dynamiques


     22    Retour sur les classes
                  e
structures de donn´es dynamiques


                  e
Structures de donn´es dynamiques

                            e             e
       Une structure de donn´es dynamique ´volue au cours du temps.
                                                      a
       Exemple de la pile: utiliser un tableau oblige ` borner la taille de la
       pile.
            ee                         e
       On pr´f`re allouer de l’espace m´moire en fonction des besoins :
                          ee      a                      a
               ajouter un ´l´ment ` la pile correspondra ` allouer (avec new)
                       e
               de la m´moire, et
                                   a e
               supprimer reviendra ` d´sallouer (avec delete) la case
               contenant l’objet.
                                           e    e        e
       ⇒ Le contenu de la pile sera donc ´clat´ dans la m´moire
                             ee                    a       ee      u
       Pour ne pas perdre d’´l´ments, on indique ` chaque ´l´ment o` se
                          ee
       trouve le prochain ´l´ment.
                        a
       Cela correspond ` la notion de liste chaˆ ee
                                               ın´
                  e
structures de donn´es dynamiques


          ın´
Listes chaˆ ees

                                 ın´
       Un maillon d’une liste chaˆ ee:
        c l a s s element {
        public :
            int val ;
            element ∗ s u i v a n t ;
        };
                                                       ee
       Le champ suivant contient l’adresse du prochain ´l´ment de la liste
       (ou 0).
                                       ee
       On utilise l’adresse du premier ´l´ment de la liste...

       Parcours de liste, inversion, longueur. . .
                              ın´
       Listes doublement chaˆ ees, circulaires, . . .
Retour sur les classes


Plan


      18    Pointeurs


      19    Pointeurs et tableaux


      20    new et delete


      21                      e
            structures de donn´es dynamiques


      22    Retour sur les classes
Retour sur les classes


Classes et pointeurs



                 p->champ raccourci pour (*p).champ
                 p->fct() raccourci pour (*p).fct()
                                          e
                 Lorsqu’on alloue de la m´moire pour stocker un objet de type
                                             e
                 T, un constructeur est appel´ :
                         soit celui sans argument (dans le cas d’un “new T”),
                                                                        e
                         soit un avec argument si des arguments sont pr´sents ( “new
                         T(a1,...,aN) ;”).
                           e                                        e    a
                 Dans la d´finition des fonctions membre, on peut acc´der `
                 l’adresse de l’objet courant: pointeur this.
      e
Cinqui`me partie V

       e
  Compl´ments
     e
Compl´ments




      e
     H´ritage
                         e
     Programmation orient´e objet
      e e     e
     G´n´ricit´ (classes, fonctions)
     GDB
     Exceptions
     ...

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:37
posted:9/11/2010
language:French
pages:193