SlideShare une entreprise Scribd logo
Initiation au Langage C

      Alexandre Mesl´
                    e

       16 juin 2009
Table des mati`res
              e

1 Notes de cours                                                                                                                                                          6
  1.1 Introduction . . . . . . . . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    6
      1.1.1 D´finitions et terminologie . .
                e                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    6
      1.1.2 Hello World ! . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    7
      1.1.3 Structure d’un programme C           .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    7
      1.1.4 Commentaires . . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    8
  1.2 Variables . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    9
      1.2.1 D´claration . . . . . . . . . .
                e                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    9
      1.2.2 Affectation . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    9
      1.2.3 Saisie . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   10
      1.2.4 Affichage . . . . . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   10
      1.2.5 Entiers . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   10
      1.2.6 Flottants . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   11
      1.2.7 Caract`res . . . . . . . . . . .
                      e                          .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   12
      1.2.8 Constantes . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   12
  1.3 Op´rateurs . . . . . . . . . . . . . .
         e                                       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   14
      1.3.1 G´n´ralit´s . . . . . . . . . .
                e e     e                        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   14
      1.3.2 Les op´rateurs unaires . . . .
                      e                          .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   14
      1.3.3 Les op´rateurs binaires . . . .
                      e                          .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   15
      1.3.4 Formes contract´es . . . . . .
                               e                 .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   16
      1.3.5 Op´rations h´t´rog`nes . . .
                  e         ee e                 .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   17
      1.3.6 Les priorit´s . . . . . . . . . .
                          e                      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   18
  1.4 Traitements conditionnels . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   19
      1.4.1 Si ... Alors . . . . . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   19
      1.4.2 Switch . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   21
      1.4.3 Bool´ens . . . . . . . . . . . .
                    e                            .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   22
      1.4.4 Les priorit´s . . . . . . . . . .
                          e                      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   23
      1.4.5 Pr´processeur . . . . . . . . .
                 e                               .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   23
  1.5 Boucles . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   25
      1.5.1 D´finitions et terminologie . .
                e                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   25
      1.5.2 while . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   25
      1.5.3 do ... while . . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   26
      1.5.4 for . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   26
      1.5.5 Accolades superflues . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   27
  1.6 Tableaux . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   28
      1.6.1 D´finitions . . . . . . . . . .
                e                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   28
      1.6.2 D´claration . . . . . . . . . .
                e                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   28
      1.6.3 Initialisation . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   28
      1.6.4 Acc`s aux ´l´ments . . . . . .
                   e      ee                     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   29
      1.6.5 Exemple . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   29
  1.7 Chaˆ ınes de caract`res . . . . . . . .
                          e                      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   32
      1.7.1 Exemple . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   32
      1.7.2 D´finition . . . . . . . . . . .
                e                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   32


                                                             1
1.7.3 D´claration . . . . . . . . . . . . . .
                 e                                            .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   32
        1.7.4 Initialisation . . . . . . . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   32
        1.7.5 Acc`s aux ´l´ments . . . . . . . . . .
                    e       ee                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   33
        1.7.6 Affichage . . . . . . . . . . . . . . .           .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   33
        1.7.7 Saisie . . . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   33
        1.7.8 Probl`mes li´s ` la saisie bufferis´e .
                      e       e a                   e         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   35
        1.7.9 La biblioth`que string.h . . . . . .
                            e                                 .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   35
        1.7.10 Exemple . . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   35
   1.8 Fonctions . . . . . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   37
        1.8.1 Les proc´dures . . . . . . . . . . . .
                          e                                   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   37
        1.8.2 Variables locales . . . . . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   39
        1.8.3 Passage de param`tres . . . . . . . .
                                    e                         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   40
        1.8.4 Les fonctions . . . . . . . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   42
        1.8.5 Passages de param`tre par r´f´rence
                                     e         ee             .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   44
   1.9 Structures . . . . . . . . . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   45
        1.9.1 D´finition . . . . . . . . . . . . . . .
                 e                                            .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   45
        1.9.2 D´claration . . . . . . . . . . . . . .
                 e                                            .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   45
        1.9.3 Acc`s aux champs . . . . . . . . . .
                    e                                         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   45
        1.9.4 Typedef . . . . . . . . . . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   46
        1.9.5 Tableaux de structures . . . . . . . .          .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   46
        1.9.6 Structures et fonctions . . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   47
   1.10 Pointeurs . . . . . . . . . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   50
        1.10.1 Introduction . . . . . . . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   50
        1.10.2 Tableaux . . . . . . . . . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   52
        1.10.3 Allocation dynamique de la m´moire e           .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   55
        1.10.4 Passage de param`tres par r´f´rence
                                    e          ee             .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   58
        1.10.5 Pointeurs sur fonction . . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   60
   1.11 Fichiers . . . . . . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   61
        1.11.1 D´finitions . . . . . . . . . . . . . .
                 e                                            .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   61
        1.11.2 Ouverture et fermeture . . . . . . .           .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   61
        1.11.3 Lecture et ´criture . . . . . . . . . .
                            e                                 .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   62
   1.12 Listes Chaˆ ees . . . . . . . . . . . . . . . .
                   ın´                                        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   65
        1.12.1 Le probl`me . . . . . . . . . . . . . .
                          e                                   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   65
        1.12.2 Pointeurs et structures . . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   65
        1.12.3 Un premier exemple . . . . . . . . .           .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   68
        1.12.4 Le chaˆ  ınage . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   69
        1.12.5 Utilisation de malloc . . . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   71
        1.12.6 Op´rations . . . . . . . . . . . . . .
                   e                                          .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   74
        1.12.7 Listes doublement chaˆ ees . . . . .
                                         ın´                  .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   74

2 Exercices                                                                                                                                                           76
  2.1 Variables et op´rateurs . . . . . . . . . .
                     e                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   76
      2.1.1 Entiers . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   76
      2.1.2 Flottants . . . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   76
      2.1.3 Caract`res . . . . . . . . . . . . .
                    e                                 .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   77
      2.1.4 Op´rations sur les bits (difficiles)
                 e                                    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   77
      2.1.5 Morceaux choisis (difficiles) . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   78
  2.2 Traitements conditionnels . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   79
      2.2.1 Prise en main . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   79
      2.2.2 Switch . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   79
      2.2.3 L’´chiquier . . . . . . . . . . . .
               e                                      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   80
      2.2.4 Heures et dates . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   80
      2.2.5 Intervalles et rectangles . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   81
      2.2.6 Pr´processeur . . . . . . . . . . .
                e                                     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   81
      2.2.7 Nombres et lettres . . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   83


                                                          2
2.3  Boucles . . . . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    84
     2.3.1 Compr´hension . . . . . . . . . . . . .
                     e                                    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    84
     2.3.2 Utilisation de toutes les boucles . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    85
     2.3.3 Choix de la boucle la plus appropri´e   e      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    85
     2.3.4 Morceaux choisis . . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    85
     2.3.5 Extension de la calculatrice . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    86
2.4 Tableaux . . . . . . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    88
     2.4.1 Exercices de compr´hension . . . . . .
                                  e                       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    88
     2.4.2 Prise en main . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    88
     2.4.3 Indices . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    89
     2.4.4 Recherche s´quentielle . . . . . . . . .
                           e                              .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    89
     2.4.5 Morceaux choisis . . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    89
2.5 Chaˆ ınes de caract`res . . . . . . . . . . . . .
                         e                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    91
     2.5.1 Prise en main . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    91
     2.5.2 Les fonctions de string.h . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    91
     2.5.3 Morceaux choisis . . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    92
2.6 Fonctions . . . . . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    93
     2.6.1 G´om´trie . . . . . . . . . . . . . . . .
              e e                                         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    93
     2.6.2 Arithm´tique . . . . . . . . . . . . . .
                     e                                    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    95
     2.6.3 Passage de tableaux en param`tre . .
                                              e           .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    96
     2.6.4 D´composition en facteurs premiers .
              e                                           .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    97
     2.6.5 Statistiques . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    98
     2.6.6 Chaˆ   ınes de caract`res . . . . . . . . .
                                e                         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    99
     2.6.7 Programmation d’un Pendu . . . . . .           .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    99
     2.6.8 Tris . . . . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    99
2.7 Structures . . . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   101
     2.7.1 Prise en main . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   101
     2.7.2 Heures de la journ´e . . . . . . . . . .
                                 e                        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   101
     2.7.3 R´pertoire t´l´phonique . . . . . . . .
              e            ee                             .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   103
2.8 Pointeurs . . . . . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   104
     2.8.1 Aliasing . . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   104
     2.8.2 Tableaux . . . . . . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   104
     2.8.3 Exercices sans sous-programmes . . .           .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   105
     2.8.4 Allocation dynamique . . . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   105
     2.8.5 Pointeurs et pointeurs de pointeurs . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   105
     2.8.6 Passages de param`tres par r´f´rence .
                                 e           ee           .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   106
     2.8.7 Les pointeurs sans ´toile . . . . . . . .
                                  e                       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   107
     2.8.8 Tableau de tableaux . . . . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   108
     2.8.9 Triangle de Pascal . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   108
     2.8.10 Pointeurs et r´cursivit´ . . . . . . . .
                             e       e                    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   108
     2.8.11 Tri fusion . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   109
2.9 Fichiers . . . . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   112
     2.9.1 Ouverture et fermeture . . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   112
     2.9.2 Lecture . . . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   112
     2.9.3 Ecriture . . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   112
     2.9.4 Lecture et ´criture . . . . . . . . . . .
                         e                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   112
     2.9.5 Enigma . . . . . . . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   112
2.10 Matrices . . . . . . . . . . . . . . . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   117
2.11 Listes Chaˆ ees . . . . . . . . . . . . . . . . .
                ın´                                       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   118
     2.11.1 Pointeurs et structures . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   118
     2.11.2 Maniement du chaˆ    ınage . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   118
     2.11.3 Op´rations sur les listes chaˆ ees . . .
                e                          ın´            .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   120
     2.11.4 Listes doublement chaˆ ees . . . . . .
                                     ın´                  .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   120
     2.11.5 Fonctions r´cursives et listes chaˆ ees
                          e                     ın´       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   121



                                                   3
A Quelques corrig´s e                                                                                                                                    124
  A.1 Variables et op´rateurs . . . . . . . . . . . . . . . .
                       e                                         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   124
       A.1.1 Entiers . . . . . . . . . . . . . . . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   124
       A.1.2 Flottants . . . . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   125
       A.1.3 Caract`res . . . . . . . . . . . . . . . . . . .
                      e                                          .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   126
       A.1.4 Op´rations binaires . . . . . . . . . . . . . .
                  e                                              .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   127
       A.1.5 Morceaux choisis . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   128
  A.2 Traitements conditionnel . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   130
       A.2.1 Prise en Main . . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   130
       A.2.2 Switch . . . . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   133
       A.2.3 Heures et dates . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   133
       A.2.4 Echiquier . . . . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   134
       A.2.5 Intervalles et rectangles . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   136
       A.2.6 Nombres et lettres . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   139
  A.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   141
       A.3.1 Utilisation de toutes les boucles . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   141
       A.3.2 Choix de la boucle la plus appropri´e . . .
                                                    e            .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   142
       A.3.3 Morceaux choisis . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   143
  A.4 Tableaux . . . . . . . . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   146
       A.4.1 Prise en main . . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   146
       A.4.2 Indices . . . . . . . . . . . . . . . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   147
       A.4.3 Recherche s´quentielle . . . . . . . . . . . .
                           e                                     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   147
       A.4.4 Morceaux choisis . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   149
  A.5 Chaˆ ınes de caract`res . . . . . . . . . . . . . . . .
                         e                                       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   151
       A.5.1 Prise en main . . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   151
       A.5.2 Les fonctions de string.h . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   152
       A.5.3 Morceaux choisis . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   152
  A.6 Fonctions . . . . . . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   154
       A.6.1 G´om´trie . . . . . . . . . . . . . . . . . . .
                e e                                              .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   154
       A.6.2 Arithm´tique . . . . . . . . . . . . . . . . .
                       e                                         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   156
       A.6.3 Passage de tableaux en param`tre . . . . .
                                               e                 .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   158
       A.6.4 D´composition en facteurs premiers . . . .
                e                                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   159
       A.6.5 Statistiques . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   160
       A.6.6 Chaines de caract`res . . . . . . . . . . . .
                                 e                               .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   161
       A.6.7 Programmation d’un pendu . . . . . . . . .          .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   162
       A.6.8 Tris . . . . . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   163
  A.7 Structures . . . . . . . . . . . . . . . . . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   165
       A.7.1 Heures . . . . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   165
       A.7.2 R´pertoire t´l´phonique . . . . . . . . . . .
                e          ee                                    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   166
  A.8 Pointeurs . . . . . . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   170
       A.8.1 Exercices sans sous-programmes . . . . . .          .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   170
       A.8.2 Pointeurs sans ´toiles et triangle de Pascal .
                              e                                  .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   171
       A.8.3 Fonctions r´cursives . . . . . . . . . . . . .
                          e                                      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   173
       A.8.4 Tri fusion . . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   177
  A.9 Fichiers . . . . . . . . . . . . . . . . . . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   181
       A.9.1 Ouverture et fermeture . . . . . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   181
       A.9.2 Lecture . . . . . . . . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   181
       A.9.3 Ecriture . . . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   181
       A.9.4 Lecture et ´criture . . . . . . . . . . . . . .
                         e                                       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   182
  A.10 Listes Chaˆ ees . . . . . . . . . . . . . . . . . . . .
                  ın´                                            .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   184
       A.10.1 Pointeurs et structures . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   184
       A.10.2 Maniement du chaˆ   ınage . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   184
       A.10.3 Listes doublement chaˆ ees . . . . . . . . .
                                      ın´                        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   187
       A.10.4 Fonctions r´cursives et listes chaˆ ees . . .
                          e                      ın´             .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   190



                                                     4
B Projets                                                                                              194
  B.1 Agenda (pour les PPAs) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

A M´thodologie
    e                                                                                                                                                                     195
  A.1 Le probl`me . . . . . . . . . . . . . .
               e                                  .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   195
  A.2 Les r`gles d’or . . . . . . . . . . . . .
            e                                     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   195
      A.2.1 G´n´ralit´s . . . . . . . . . .
                e e     e                         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   195
      A.2.2 Fonctions . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   195
      A.2.3 Compilation s´par´e . . . . .
                             e e                  .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   196
  A.3 D´bogage . . . . . . . . . . . . . . .
       e                                          .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   196
  A.4 Dur´e de vie du code . . . . . . . . .
          e                                       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   196
      A.4.1 Le code doit ˆtre r´utilisable
                            e     e               .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   196
      A.4.2 Le code doit ˆtre adaptable .
                            e                     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   197
  A.5 Exemple : le carnet de contacts . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   197
      A.5.1 util.h . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   197
      A.5.2 util.c . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   197
      A.5.3 tableau.h . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   198
      A.5.4 tableau.c . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   199
      A.5.5 eMails.c . . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   201
      A.5.6 makefile . . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   204




                                                              5
Chapitre 1

Notes de cours

1.1     Introduction
1.1.1    D´finitions et terminologie
          e
Un programme ex´cutable est une suite d’instructions ex´cut´e par le processeur. Ces instructions sont
                   e                                      e e
tr`s difficile ` comprendre, si par exemple, vous ouvrez avec un ´diteur de texte (notepad, emacs, etc) un
  e          a                                                 e
fichier ex´cutable, vous verrez s’afficher un charabia incompr´hensible :
         e                                                   e

00000000
0000001f
0000003e
0000005d
0000007c
0000009b
000000ba
000000d9
000000f8
00000117
00000136
00000155
00000174
00000193
000001b2
000001d1
000001f0
0000020f
0000022e
0000024d
0000026c
0000028b
000002aa
000002c9
000002e8
00000307
...

Il n’est pas envisageable de cr´er des programmes en ´crivant des suites de chiffres et de lettres. Nous
                                e                    e
allons donc utiliser des langages de programmation pour ce faire.

Un programme C est un ensemble d’instructions qui se saisit dans un fichier .c ` l’aide d’un ´diteur
                                                                              a             e


                                                   6
(ex. : Notepad), ce type de fichier s’appelle une source. Les instructions qui y sont ´crites s’appellent
                                                                                           e
du code ou encore le code source. Un compilateur est un logiciel qui lit le code source et le convertit
en un code ex´cutable, c’est-`-dire un ensemble d’instructions compr´hensible par le processeur. La
                 e                a                                          e
compilation d’une source se fait en deux ´tapes : la compilation proprement dite et le linkage. On utilise
                                          e
en g´n´ral le terme compilation en englobant les deux ´tapes pr´c´demment cit´es.
     e e                                                  e        e e             e
    – La compilation ` proprement parler produit un fichier objet, dont l’extension est .obj.
                       a
    – Les sources peuvent ˆtre r´parties dans plusieurs fichiers, ceux-ci doivent tous ˆtre compil´s s´par´ment.
                           e    e                                                     e          e e e
      Ensuite, le linkage des diff´rents fichiers objets est assemblage produisant un ex´cutable .exe.
                                  e                                                       e
Certains environnement de d´veloppement servent d’´diteur, et prennent en charge la compilation et le
                              e                         e
linkage (eclipse, dev-C++).

1.1.2      Hello World !
Allez sur http://www.01net.com/telecharger/windows/Programmation/langage/fiches/2327.html,
cliquez sur t´l´charger. Installez Dev-C++. Ouvrez un nouveau fichier source. Copiez-collez le code ci-
             ee
dessous dans l’´diteur :
                e
#include<s t d i o . h>
#include<c o n i o . h>

int main ( )
{
  p r i n t f ( ” H e l l o World !  n” ) ;
  getch ( ) ;
  return 0 ;
}
Sauvegardez ce fichier sous le nom helloWorld.c. Dans le menu Ex´cuter, cliquez sur Compiler. Remar-
                                                                e
quez que la compilation a produit un fichier helloWorld.exe. Vous avez deux fa¸ons de l’ex´cuter :
                                                                             c           e
   – double-cliquez directement sur helloWorld.exe
   – Dans le menu Ex´cuter, cliquez sur ex´cuter.
                      e                    e

1.1.3      Structure d’un programme C
Importation des biblioth`ques
                        e

#include<s t d i o . h>
#include<c o n i o . h>
Selon ce que l’on souhaite faire dans notre programme, on peut avoir besoin de diff´rentes fonctions.
                                                                                  e
Celles-ci sont disponibles dans des biblioth`ques. Par exemple :
                                            e
   – stdio.h propose des fonctions de saisie et d’affichage
   – conio.h propose d’autre fonctions d’entr´es-sorties
                                                e

Corps du programme

int main ( )
{
         p r i n t f ( ” H e l l o world ! ” ) ;
         getch ( ) ;
         return 0 ;
}
On place dans les accolades du main les instructions que l’on souhaite voir s’ex´cuter :
                                                                                e
int main ( )
{


                                                     7
<i n s t r u c t i o n s A E x e c u t e r >
            return 0 ;
}
Remarquez que chaque ligne se termine par un points-virgule. Pour afficher une variable de type apha-
num´rique en C, on utilise printf(<valeur ` afficher>) ;. Les litt´raux de type alphanum´riques en
    e                                        a                        e                     e
C s’´crivent entre doubles quotes. getch() ; nous sert ` suspendre l’ex´cution du programme jusqu’` ce
    e                                                  a                e                         a
que l’utilisateur appuie sur une touche.
1.1.4      Commentaires
Un commentaire est une s´quence de caract`res ignor´e par le compilateur, on s’en sert pour expliquer
                          e                  e        e
des portions de code. Alors ayez une pens´e pour les pauvres programmeurs qui vont reprendre votre
                                           e
code apr`s vous, le pauvre correcteur qui va essayer de comprendre votre pens´e profonde, ou bien plus
         e                                                                   e
simplement ` vous-mˆme au bout de six mois, quand vous aurez compl`tement oubli´ ce que vous aviez
             a       e                                                e            e
dans la tˆte en codant. On d´limite un commentaire par /* et */. Par exemple,
         e                  e
int main ( )
{
         /∗
         Ceci e s t un commentaire :
                        L ’ i n s t r u c t i o n c i −d e s s o u s a f f i c h e ’ ’ H e l l o morld ! ’ ’
         Ces p h r a s e s s o n t i g n o r ´ e s par l e c o m p i l a t e u r .
                                                  e
         ∗/
         p r i n t f ( ” H e l l o world !  n” ) ;
         return 0 ;
}




                                                              8
1.2        Variables
Une variable est un emplacement de la m´moire dans lequel est stock´e une valeur. Chaque variable porte
                                          e                         e
une nom et c’est ce nom qui sert ` identifi´ l’emplacement de la m´moire repr´sent´ par cette variable.
                                   a        e                      e          e    e
Pour utiliser une variable, la premi`re ´tape est la d´claration.
                                    e e               e

1.2.1      D´claration
            e
D´clarer une variable, c’est pr´venir le compilateur qu’un nom va ˆtre utilis´ pour d´signer un emplace-
 e                             e                                     e         e       e
ment de la m´moire. En C, on d´clare les variables juste apr`s l’accolade suivant main() (pour le moment).
             e                  e                            e
On place les instructions ` ex´cuter ` la suite de la d´claration de variables.
                          a e        a                 e
main ( )
{
             <d e c l a r a t i o n de v a r i a b l e s >
             <i n s t r u c t i o n s a executer >
}
Nous ne travaillerons pour le moment que sur les variables de type num´rique entier. Le type qui y
                                                                             e
correspond, en C, est int. On d´clare les variables enti`res de la mani`re suivante :
                               e                        e              e
int <v a r 1 >, <v a r 2 >, . . . , <var n >;
Cette instruction d´clare les variables var 1, var 2, ..., var n de type entier. Par exemple,
                   e
#include<s t d i o . h>

int main ( )
{
         int v a r i a b l e 1 , v a r i a b l e 2 ;
         int a u t r e v a r i a b l e 1 , a u t r e v a r i a b l e 2 ;
         return 0 ;
}
On appelle bloc le contenu des accolades du main.

1.2.2      Affectation
Si on souhaite affecter ` la variable v une valeur, on utilise l’op´rateur =. Par exemple,
                       a                                          e
int main ( )
{
         int v ;
        v = 5;
         return 0 ;
}
Ce programme d´clare une variable de type entier que l’on appelle v, puis lui affecte la valeur 5. Comme
                 e
vous venez de le voir, il est possible d’´crire directement dans le code une valeur que l’on donne ` une
                                         e                                                         a
variable. Notez l’abscence de include, ce programme n’effectue aucune entr´e-sortie, il n’est donc pas
                                                                               e
n´cessaire d’importer les biblioth`ques d’entr´es/sorties.
 e                                e             e

Les op´rations arihm´tiques disponibles sont l’addition (+), la soustraction (-), la multiplication (*),
        e              e
la division enti`re dans l’ensemble des entiers relatifs (quotient : /, reste : %).
                e
int main ( )
{
         int v , w, z ;
        v = 5;
        w = v + 1;


                                                               9
z = v + w / 2;
            v = z % 3;
            v = v ∗ 2;
            return 0 ;
}


1.2.3      Saisie
Traduisons en C l’instruction Saisir <variable> que nous avons vu en algorithmique. Pour r´cup´rer  e    e
la saisie d’un utilisateur et la placer dans une variable <variable>, on utilise l’instruction suivante :
s c a n f ( ”%d” , &<v a r i a b l e >);
scanf suspend l’ex´cution du programme jusqu’` ce que l’utilisateur ait saisi une valeur et press´ la
                   e                               a                                              e
touche return. La valeur saisie est alors affet´e ` la variable <variable>. N’oubliez surtout pas le &,
                                              e a
sinon des choses absurdes pourraient se produire !

1.2.4      Affichage
Traduisons maintenant l’instruction Afficher variable en C. Cette instruction permet d’afficher la
valeur d’une variable.
p r i n t f ( ”%d” , <v a r i a b l e >);
Cette instruction affiche la valeur contenue dans la variable variable (ne vous laissez pas impressionner
par l’apparente complexit´ de cette instruction !). Nous avons ´tendu, en algorithmique, l’instruction
                          e                                     e
Afficher en intercalant des valeurs de variables entre les messages affich´s. Il est possible de faire de
                                                                          e
mˆme en C :
  e
p r i n t f ( ” l a v a l e u r de l a v a r i a b l e v e s t %d” , v ) ;
Cette instruction substitue ` %d la valeur de la variable v. Il est possible de l’´tendre ` volont´ :
                            a                                                     e       a       e
p r i n t f ( ” l e s v a l e u r s d e s v a r i a b l e s x , y e t z s o n t %d , %d e t %d” , x , y , z ) ;
Cette instruction substitue ` chaque %d les valeurs des trois variables x, y et z. Par exemple, le programme
                            a
suivant
#include<s t d i o . h>

int main ( )
{
         int a , b , c ;
         a = 1;
        b = 2;
         c = 3
         p r i n t f ( ”La v a l e u r de a e s t %d , c e l l e de b e s t %d , e t c e l l e de ”
                                             ” c e s t %d . ” , a , b , c ) ;
         return 0 ;
}
affiche
La valeur de a est 1, celle de b est 2, et celle de c est 3.

1.2.5      Entiers
Trois types de base servent ` repr´senter les entiers :
                            a     e
     nom     taille (t) nombre de valeurs (28t ) chaˆ de format
                                                        ıne
     short 1 octet       28 valeurs                  %hd
     int     2 octets 216 valeurs                    %d
     long    4 octets 232 valeurs                    %ld


                                                          10
Entiers non sign´s
                e
Par d´faut, les entiers permettent de stocker des valeurs de signe quelconque. Si on pr´fixe un type entier
      e                                                                                e
par unsigned, on le restreint ` des valeurs uniquement positives. Dans ce cas, on a
                                 a
     nom                  taille (t) nombre de valeurs (28t ) valeur min valeur max format
     unsigned short 1 octet          28 valeurs                 0           28 − 1        %hu
                                      16
     unsigned int         2 octets 2 valeurs                    0           216 − 1       %u
     unsigned long        4 octets 232 valeurs                  0           232 − 1       %lu
La plage de valeur d’un unsigned short, encod´e en binaire, est
                                                  e

                 {0000 0000, 0000 0001, 0000 0010, 0000 0011, . . . , 1111 1110, 1111 1111}

Entiers sign´s
            e
Si par contre les donn´es sont sign´es, on a comme plage de valeurs
                        e            e
     nom      taille (t) nombre de valeurs (28t ) plus petite valeur        plus grande valeur
     short 1 octet        28 valeurs              −27                       27 − 1
                           16
     int      2 octets 2 valeurs                  −215                      215 − 1
                           32
     long     4 octets 2 valeurs                  −231                      231 − 1
La plage de valeur d’un short, encod´e en binaire, est aussi
                                       e

                 {0000 0000, 0000 0001, 0000 0010, 0000 0011, . . . , 1111 1110, 1111 1111}
Mˆme si les codages sont les mˆmes, la signification ne l’est pas, les nombres entiers positifs sont cod´s
  e                           e                                                                        e
sur l’intervalle :


      {0000 0000, 0000 0001, 0000 0010, 0000 0011, . . . , 0111 1100, 0111 1101, 0111 1110, 0111 1111}

Et les nombres n´gatifs sur l’intervalle
                e


      {1000 0000, 1000 0001, 1000 0010, 1000 0011, . . . , 1111 1100, 1111 1101, 1111 1110, 1111 1111}

Les nombres n´gatifs sont dispos´s du plus grand jusqu’au plus petit, l’intervalle pr´c´dent code les
             e                  e                                                    e e
valeurs :

                        {−27 , −(27 − 1), −(27 − 2), −(27 − 3), . . . , −4, −3, −2, −1}
Les op´rations arithm´tiques sont ex´cut´es assez bˆtement, si vous calculez 0111 1111 + 0000 0001, ce
      e               e              e e            e
qui correspond ` (27 − 1) + 1, le r´sultat math´matique est 27 , ce qui se code 1000 0000, ce qui est le
                a                  e            e
codage de −27 . Soyez donc attentifs, en cas de d´passement de capacit´ d’un nombre entier, vous vous
                                                  e                      e
retrouverez avec des nombres qui ne veulent rien dire. Si vous souhaitez faire des calculs sur des r´els, un
                                                                                                    e
type flottant sera davantage adapt´.e

1.2.6    Flottants
Les flottants servent ` repr´senter les r´els. Leur nom vient du fait qu’on les repr´sente de fa¸on scien-
                        a     e            e                                          e            c
tifique : un nombre d´cimal (` virgule) muni d’un exposant (un d´calage de la virgule). Trois types de
                         e      a                                     e
base servent ` repr´senter les flottants :
               a     e
      nom              taille       chaˆ de format
                                       ıne
      float            4 octet      %f
      double           8 octets     %f
      long double 10 octets %Lf
Il est conventionel d’´crire des litt´raux flottants avec un point, par exemple l’approximation ` 10−2 pr`s
                       e             e                                                           a        e
de π s’ecrit 3.14. Il est aussi possible d’utiliser la notation scientifique, par exemple le d´cimal 1 000
                                                                                               e
s’´crit 1e3, ` savoir 1.103 .Nous nous limiterons ` la description du type float, les autres types ob´issent
  e          a                                    a                                                  e
a
` des r`gles similaires.
        e


                                                      11
Repr´sentation en m´moire d’un float
    e              e
Le codage d’un nombre de type float (32 bits) est d´coup´ en trois parties :
                                                         e      e
     partie            taille
     le bit de signe 1 bit
     l’exposant        8 bits
     la mantisse       23 bits
Le nombre est positif si le bit de signe est ` 0, n´gatif si le bit de signe est ` 1. La mantisse et l’exposant
                                             a     e                             a
                                                                                                m
sont cod´s en binaire, la valeur absolue d’un flottant de mantisse m et d’exposant e est 23 .2e . Le plus
         e
                                                                                                2
                                                              (223 − 1)
grand entier qu’il est possible de coder sur 23 octets est              , le plus grand exposant est 27 , donc
                                                                  223
                            (223 − 1) (27 )                            (223 − 1) (27 )
le plus grand flottant est        23
                                     .2 , donc le plus petit est −               .2 .
                               2                                          223

1.2.7     Caract`res
                e
Un char sert ` repr´senter le code ASCII d’un caract`re, il est donc cod´ sur 1 octet. Il est possible
               a     e                                 e                e
d’affecter ` une telle variable toute valeur du code ASCII entour´e de simples quotes. Par exemple,
           a                                                       e
l’affectation suivante place dans a le code ASCII du caract`re ’B’.
                                                          e
char a ;
a = ’B ’ ;
De la mˆme fa¸on que l’on code des nombres entiers sur 1 octet avec un short, un char contient avant
        e      c
tout un nombre cod´ sur 1 octet. Pour afficher le caract`re corrspondant au code ASCII stock´ dans un
                     e                                   e                                     e
char, on utilise la chaˆ de format %c, et pour afficher le code ASCII lui-mˆme on utilise la chaˆ de
                       ıne                                                    e                    ıne
format %d. Si on souhaite manipuler des char comme des nombres, le type unsigned char permet de
coder des valeurs positives sur 1 octet, alors que char code aussi bien des nombres positifs que n´gatifs.
                                                                                                  e
Par cons´quent, les caract`res de code ASCII 255 et 128 correspondent aux unsigned char de valeurs
         e                 e
255 et 128 et aux char de valeurs −1 et −128.

1.2.8     Constantes
Une constante est une valeur portant un nom, contrairement aux variables, elles ne sont pas modifiables.
Les constantes en C sont non typ´es, on les d´finit dans l’entˆte de la source, juste en dessous des #include.
                                e            e               e
La syntaxe est #define <NOM CONSTANTE> <valeurConstante>, par exemple #define N 25 d´finit une        e
constante N qui a la valeur 25. Au d´but de la compilation, un programme appel´ pr´processeur
                                         e                                                  e   e
effectue un rechercher/remplacer et substitue ` toutes les occurences de <NOM CONSTANTE> la valeur
                                                  a
<valeurConstante>. Faites donc tr`s attention au fait que dans l’exemple pr´sent, le pr´processeur
                                      e                                               e           e
va remplacer tous les N par des 25. Donc si une variable s’appelle N , le pr´processeur va le remplacer
                                                                                 e
par un 25 ! Si par exemple vous ´crivez
                                e
#include<s t d i o . h>

#define N 25

int main ( )
{
  int N;
  N = 12;
  p r i n t f ( ”N = %d” , N ) ;
  return 0 ;
}
Le pr´processeur va le transformer en
     e
#include<s t d i o . h>



                                                      12
#define N 25

int main ( )
{
  int 2 5 ;
  25 = 1 2 ;
  p r i n t f ( ”N = %d” , 2 5 ) ;
  return 0 ;
}
Vous remarquez que les seules exceptions sont les valeurs d´limit´es par des ".
                                                           e     e




                                                   13
1.3     Op´rateurs
          e
1.3.1    G´n´ralit´s
          e e     e
Op´randes et arit´
  e              e
Lorsque vous effectuez une op´ration, par exemple 3 + 4, le + est un op´rateur, 3 et 4 sont des op´randes.
                               e                                          e                          e
Si l’op´rateur s’applique ` 2 op´randes, on dit qu’il s’agit d’un op´rateur binaire, ou bien d’arit´ 2. Un
       e                  a      e                                  e                                 e
op´rateur d’arit´ 1, dit aussi unaire, s’applique ` un seul op´rande, par exemple -x, le x est l’op´rande
   e             e                                 a            e                                      e
et le - unaire est l’op´rateur qui, appliqu´ ` x, nous donne l’oppos´ de celui-ci, c’est-`-dire le nombre
                       e                    e a                         e                   a
qu’il faut additionner ` x pour obtenir 0. Il ne faut pas le confondre avec le - binaire, qui appliqu´ ` x et
                       a                                                                              ea
y, additionne ` x l’oppos´ de y.
               a          e
En C, les op´rateurs sont unaires ou binaires, et il existe un seul op´rateur ternaire.
             e                                                         e

Associativit´
            e
Si vous ´crivez une expression de la forme a + b + c, o` a, b et c sont des variables enti`res, vous
         e                                                   u                                  e
appliquez deux fois l’op´rateur binaire + pour calculer la somme de 3 nombres a, b et c. Dans quel ordre
                         e
ces op´rations sont-elles effectu´es ? Est-ce que l’on a (a + b) + c ou a + (b + c) ? Cela importe peu,
       e                        e
car le + entier est associatif, ce qui signifie qu’il est possible de modifier le parenth`sage d’une somme
                                                                                       e
d’entiers sans en changer le r´sultat. Attention : l’associativit´ est une raret´ ! Peu d’op´rateurs sont
                               e                                   e             e           e
associatifs, une bonne connaissance des r`gles sur les priorit´s et le parenth`sage par d´faut est donc
                                            e                    e              e          e
requise.

Formes pr´fixes, postfixes, infixes
         e
Un op´rateur unaire est pr´fixe s’il se place avant son op´rande, postfixe s’il se place apr`s. Un op´rateur
      e                    e                             e                                 e       e
binaire est infixe s’il se place entre ses deux op´randes (a + b), pr´fixe s’il se place avant (+ a b),
                                                   e                  e
postfixe s’il se place apr`s (a b +). Vous rencontrez en C des op´rateurs unaires pr´fixes et d’autres
                          e                                         e                    e
postfixes (on imagine difficilement un op´rateur unaire infixe), par contre tous les op´rateurs binaires
                                           e                                              e
seront infixe.

Priorit´s
       e
Les r`gles des priorit´s en C sont nombreuses et complexes, nous ne ferons ici que les esquisser. Nous
     e                e
appelerons parenth`sage implicite le parenth`sage adopt´ par d´faut par le C, c’est ` dire l’ordre
                     e                            e            e        e                    a
dans lequel il effectue les op´rations. La premi`re r`gle ` retenir est qu’un op´rateur unaire est toujours
                             e                 e    e    a                     e
prioritaire sur un op´rateur binaire.
                       e

1.3.2    Les op´rateurs unaires
               e
N´gation arithm´tique
 e             e
La n´gation arithm´tique est l’op´rateur - qui ` une op´rande x, associe l’oppos´ de x, c’est-`-dire le
    e              e              e             a      e                        e             a
nombre qu’il faut additionner ` x pour obtenir 0.
                              a

N´gation binaire
 e
La n´gation binaire ~ agit directement sur les bits de son op´rande, tous les bits ` 0 deviennent 1, et
     e                                                          e                      a
vice-versa. Par exemple, ~127 (tous les bits ` 1 sauf le premier) est ´gal ` 128 (le premier bit ` 1 et tous
                                             a                        e    a                     a
les autres ` 0).
           a

Priorit´s
       e
Tous les op´rateurs unaires sont de priorit´ ´quivalente, le parenth`sage implicite est fait le plus ` droite
            e                              ee                        e                               a
possible, on dit que ces op´rateurs sont associatifs ` droite. Par exemple, le parenth`sage implicite de
                           e                           a                                   e
l’expression ~-~i est ~(-(~i)). C’est plutˆt logique : si vous parvenez ` placer les parenth`ses diff´rement,
                                          o                             a                    e      e
prevenez-moi parce que je ne vois pas comment faire...


                                                     14
1.3.3     Les op´rateurs binaires
                e
Op´rations de d´calages de bits
  e            e
L’op´ration a >> 1 effectue un d´calage des bits de la repr´sentation binaire de a vers la droite. Tous les
     e                             e                           e
bits sont d´cal´s d’un cran vers la droite, le dernier bit disparaˆ le premier prend la valeur 0. L’op´ration
           e e                                                    ıt,                                 e
a << 1 effectue un d´calage des bits de la repr´sentation binaire de a vers la gauche. Tous les bits sont
                      e                            e
d´cal´s d’un cran vers la gauche, le premier bit disparaˆ et le dernier devient 0. Par exemple, 32 << 2
 e e                                                        ıt
associe ` 0010 0000 << 2 la valeur dont la repr´sentation binaire 1000 0000 et 32 >> 3 associe ` 0010
        a                                           e                                                 a
0000 >> 3 la valeur dont la repr´sentation binaire 0000 0100.
                                   e

Op´rations logiques sur la repr´sentation binaire
  e                            e
L’op´rateur & associe ` deux op´randes le ET logique de leurs repr´sentations binaires par exemple
     e                 a          e                                    e
60 & 15 donne 12, autrement formul´ 0011 1100 ET 0000 1111 = 0000 1100. L’op´rateur | associe `
                                      e                                              e               a
deux op´randes le OU logique de leurs repr´sentations binaires par exemple 60 | 15 donne 63, autrement
         e                                 e
formul´ 0011 1100 OU 0000 1111 = 0011 1111. L’op´rateur ^ associe ` deux op´randes le OU exclusif
       e                                               e                a       e
logique de leurs repr´sentations binaires par exemple 60 ^ 15 donne 51, autrement formul´ 0011 1100
                     e                                                                    e
OU EXCLUSIF 0000 1111 = 0011 0011. Deux ^ successifs s’annulent, en d’autres termes a^b^b=a.

Affectation
Ne vous en d´plaise, le = est bien un op´rateur binaire. Celui-ci affecte ` l’op´rande de gauche (appel´e
             e                            e                              a     e                        e
Lvalue par le compilateur), qui doit ˆtre une variable, une valeur calcul´e ` l’aide d’une expression, qui
                                       e                                  e a
est l’op´rande de droite. Attention, il est possible d’effectuer une affectation pendant l’´valuation d’une
        e                                                                                e
expression. Par exemple,
a = b + (c = 3);
Cette expression affecte ` c la valeur 3, puis affecte ` a la valeur b + c.
                        a                            a

Priorit´s
       e
Tous les op´rateurs binaires ne sont pas de priorit´s ´quivalentes. Ceux de priorit´ la plus forte sont les
              e                                       e e                              e
op´rateurs arithm´tiques (*, /, %, +, -), puis les op´rateus de d´calage de bit (<<, >>), les op´rateurs de bit
   e                e                                e           e                              e
(&, ^, |), et enfin l’affectation =. Repr´sentons dans une tableau les op´rateurs en fonction de leur priorit´,
                                       e                                e                                    e
pla¸ons les plus prioritaire en haut et les moins prioritaires en bas. Parmi les op´rateurs arithm´tiques,
    c                                                                                 e                e
les multiplications et divisions sont prioritaires sur les sommes et diff´rence :
                                                                         e
      noms       op´rateurs
                    e
      produit *, /, %
      sommes +, -
Les deux op´rateurs de d´calage sont de priorit´ ´quivalente :
               e           e                       ee
      noms                op´rateurs
                            e
      d´calage binaire >>, <<
        e
L’op´rateur & est assimil´ ` un produit, | ` une somme. Donc , & est prioritaire sur |. Comme ^ se trouve
      e                    ea               a
entre les deux, on a
      noms                   op´rateurs
                               e
      ET binaire             &
      OU Exlusif binaire ^
      OU binaire             |
Il ne nous reste plus qu’` assembler les tableaux :
                          a




                                                      15
noms                 op´rateurs
                             e
     produit              *, /, %
     somme                +, -
     d´calage binaire
      e                   >>, <<
     ET binaire           &
     OU Exlusif binaire ^
     OU binaire           |
     affectation           =
Quand deux op´rateurs sont de mˆme priorit´ le parenth`sage implicite est fait le plus ` gauche pos-
                e                  e         e          e                              a
sible, on dit que ces op´rateurs sont associatifs ` gauche. Par exemple, le parenth`sage implicite de
                        e                         a                                  e
l’expression a - b - c est
(a − b) − c
et certainement pas a - (b - c). Ayez donc cela en tˆte lorsque vous manipulez des op´rateurs non
                                                              e                      e
associatifs ! La seule exception est le =, qui est associatif ` droite. Par exemple,
                                                              a
a = b = c;
se d´compose en b = c suivi de a = b.
    e

1.3.4      Formes contract´es
                          e
Le C ´tant un langage de paresseux, tout ` ´t´ fait pour que les programmeurs aient le moins de caract`res
      e                                     ae e                                                       e
possible ` saisir. Je vous pr´viens : j’ai plac´ ce chapitre pour que soyez capable de d´crypter la bouillie
          a                  e                 e                                        e
que pondent certains programmeurs, pas pour que vous les imitiez ! Alors vous allez me faire le plaisir de
faire usage des formes contract´es avec parcimonie, n’oubliez pas qu’il est tr`s important que votre code
                                 e                                             e
soit lisible.

Unaires
Il est possible d’incr´menter (augmenter de 1) la valeur d’une variable i en ´crivant i++, ou bien ++i.
                      e                                                      e
De la mˆme fa¸on on peut d´cr´menter (diminuer de 1) i en ´crivant i-- (forme postfixe), ou bien --i
         e      c          e e                               e
(forme pr´fixe). Vous pouvez d´cider d’incr´menter (ou de d´cr´menter) la valeur d’une variable pendant
           e                  e           e               e e
un calcul, par exemple,
a = 1;
b = ( a++) + a ;
´value successivement les deux op´randes a++ et a, puis affecte leur somme ` b. L’op´rande a++ est
e                                   e                                            a        e
´valu´e ` 1, puis est incr´ment´e, donc lorsque la deuxi`me op´rande a est ´valu´e, sa valeur est 2. Donc
e     e a                 e    e                        e      e            e    e
la valeur de b apr`s l’incr´mentation est 3. L’incr´mentation contract´e sous forme postfixe s’appelle une
                  e        e                       e                  e
post-incr´mentation. Si l’on ´crit,
           e                     e
a = 1;
b = (++a ) + a ;
On op`re une pr´-incr´mentation, ++a donne lieu ` une incr´mentation avant l’´valuation de a, donc
       e          e     e                            a          e                 e
la valeur 4 est affect´e ` b. On peut de fa¸on analogue effectuer une pr´-decr´mentation ou a post-
                      e a                  c                            e      e
decr´mentation. Soyez tr`s attentifs au fait que ce code n’est pas portable, il existe des compilateurs
     e                        e
qui ´valuent les op´randes dans le d´sordre ou diff`rent les incr´mentations, donnant ainsi des r´sultats
    e               e                e             e            e                               e
autres que les r´sultats th´oriques expos´s pr´c´dement. Vous n’utiliserez donc les incr´mentation et
                e           e            e    e e                                       e
decr´mentation contract´es que lorsque vous serez certain que l’ordre d’´valuation des op´randes ne
     e                       e                                              e                e
pourra pas influer sur le r´sultat.
                           e

Binaires
Toutes les affectations de la forme variable = variable operateurBinaire expression peuvent ˆtre
                                                                                           e
contract´es sous la forme variable operateurBinaire= expression. Par exemple,
        e


                                                    16
avant        apr`s
                    e
    a = a + b a +=         b
    a = a - b a -=         b
    a = a * b a *=         b
    a = a / b a /=         b
    a = a % b a %=         b
    a = a & b a &=         b
    a = a ^ b a ^=         b
    a = a | b a |=         b
Vous vous douterez que     l’´galit´ ne peut pas ˆtre contract´e...
                             e     e             e            e

1.3.5     Op´rations h´t´rog`nes
            e         e e   e
Le fonctionnement par d´faut
                       e
Nous ordonnons de fa¸on grossi`re les types de la fa¸on suivante : long double > double > float >
                     c          e                    c
unsigned long > long > unsigned int > int > unsigned short > short > char. Dans un cal-
cul o` les op´randes sont de types h´t´rog`nes, l’op´rande dont le type T est de niveau le plus ´l´v´
     u       e                       ee e             e                                           ee e
(conform´ment ` l’ordre ´nonc´ ci-avant) est s´lectionn´ et l’autre est converti dans le type T .
         e      a       e     e               e         e

Le probl`me
        e
Il se peut cependant que dans un calcul, cela ne convienne pas. Si par exemple, vous souhaitez calculer
              1
l’inverse d’un nombre entier x, et que vous codez
              x
int i = 4 ;
 p r i n t f ( ”L ’ i n v e r s e de %d e s t %d” , i , 1/ i ) ;
Vous constaterez que r´sultat est inint´ressant au possible. En effet, comme i et 1 sont tout deux de type
                         e               e
entier, c’est la division enti`re est effectu´e, et de toute ´vidence le r´sultat est 0. Changer la chaˆ de
                              e             e               e            e                            ıne
format
int i = 4 ;
p r i n t f ( ”L ’ i n v e r s e de %d e s t %f n” , i , 1/ i ) ;
se r´v`lera aussi d’une inefficacit´ notoire : non seulement vous vous taperez un warning, mais en plus
    e e                            e
printf lira un entier en croyant que c’est un flottant. Alors comment on se sort de l` ? Ici la bidouille
                                                                                    a
est simple, il suffit d’´crire le 1 avec un point :
                      e
int i = 4 ;
p r i n t f ( ”L ’ i n v e r s e de %d e s t %f n” , i , 1 . / i ) ;
Le compilateur, voyant un op´rande de type flottant, convertit lors du calcul l’autre op´rande, i, en
                                 e                                                              e
flottant. De ce fait, c’est une division flottante et non enti`re qui est effectu´e. Allons plus loin : comment
                                                            e                 e
faire pour appliquer une division flottante ` deux entiers ? Par exemple :
                                             a
int i = 4 , j= 5 ;
p r i n t f ( ”Le q u o t i e n t de %d e t %d e s t %f n” , i , j , i / j ) ;
Cette fois-ci c’est inextricable, vous pouvez placer des points o` vous voudrez, vous n’arriverez pas `
                                                                 u                                     a
vous d´barasser du warning et ce programme persistera ` vous dire que ce quotient est -0.000000 ! Une
       e                                                 a
solution particuli`rement crade serait de recopier i et j dans des variables flottantes avant de faire la
                  e
division, une autre m´thode de bourrin est de calculer (i + 0.)/j. Mais j’esp`re que vous r´alisez que
                        e                                                      e             e
seuls les boeufs proc`dent de la sorte.
                      e

Le cast
Le seul moyen de vous sortir de l` est d’effectuer un cast, c’est ` dire une conversion de type sur com-
                                 a                               a
mande. On caste en pla¸ant entre parenth`se le type dans lequel on veut convertir juste avant l’op´rande
                        c                 e                                                       e
que l’on veut convertir. Par exemple,


                                                          17
int i = 4 , j= 5 ;
p r i n t f ( ”Le q u o t i e n t de %d e t %d e s t %f n” , i , j , ( f l o a t ) i / j ) ;
Et l`, ¸a fonctionne. La variable valeur contenue dans i est convertie en float et de ce fait, l’autre
    a c
op´rande, j, est aussi convertie en float. La division est donc une division flottante. Notez bien que le
  e
cast est un op´rateur unaire, donc prioritaire sur la division qui est un op´rateur binaire, c’est pour ¸a
               e                                                              e                         c
que la conversion de i a lieu avant la division. Mais si jamais il vous vient l’id´e saugrenue d’´crire
                                                                                  e              e
int i = 4 , j= 5 ;
p r i n t f ( ”Le q u o t i e n t de %d e t %d e s t %f n” , i , j , ( f l o a t ) ( i / j ) ) ;
Vous constaterez tr`s rapidement que c’est une alternative peu intelligente. En effet, le r´sulat est flottant,
                   e                                                                        e
mais comme la division a lieu avant toute conversion, c’est le r´sultat d’une division enti`re qui est converti
                                                                e                          e
en flottant, vous avez donc le mˆme r´sultat que si vous n’aviez pas du tout cast´.
                                 e    e                                              e

1.3.6     Les priorit´s
                     e
Ajoutons le cast au tableau des priorit´s de nos op´rateurs :
                                       e           e
    noms                 op´rateurs
                            e
    op´rateurs unaires cast, -, ~, ++, --
       e
    produit              *, /, %
    somme                +, -
    d´calage binaire
     e                   >>, <<
    ET binaire           &
    OU Exlusif binaire ^
    OU binaire           |
    affectation           =




                                                         18
1.4       Traitements conditionnels
On appelle traitement conditionnel un portion de code qui n’est pas ex´cut´e syst´matiquement, c’est `
                                                                         e e     e                   a
dire des instructions dont l’ex´cution est conditionn´e par le succ`s d’un test.
                               e                     e             e

1.4.1      Si ... Alors
Principe
En algorithmique un traitement conditionnel se r´dige de la sorte :
                                                e
    si condition alors
        instructions
    fin

Si la condition est v´rifi´e, alors les instructions sont ex´cut´es, sinon, elles ne sont pas ex´cut´es.
                      e e                                   e e                                e e
L’ex´cution de l’algorithme se poursuit alors en ignorant les instructions se trouvant entre le alors
     e
et le finSi. Un traitement conditionnel se code de la sorte :
i f (< c o n d i t i o n >)
{
            <i n s t r u c t i o n s >
}
Notez bien qu’il n’y a pas de point-virgule apr`s la parenth`se du if.
                                               e            e

Comparaisons
La formulation d’une condition se fait souvent ` l’aide des op´rateurs de comparaison. Les op´rateurs de
                                                  a           e                              e
comparaison disponibles sont :
    – == : ´galit´
            e     e
    – != : non-´galit´
                 e    e
    – <, <= : inf´rieur `, respectivement strict et large
                 e      a
    – >, >= : sup´rieur `, respectivement strict et large
                   e     a
Par exemple, la condition a == b est v´rifi´e si et seulement si a et b ont la mˆme valeur au moment o`
                                         e e                                   e                       u
le test est ´valu´. Par exemple,
            e    e
#include<s t d i o . h>

int main ( )
{
         int i ;
         p r i n t f ( ” S a i s i s s e z une v a l e u r : ” ) ;
         s c a n f ( ”%d” , &i ) ;
         i f ( i == 0 )
         {
                         p r i n t f ( ”Vous avez s a i s i une v a l e u r n u l l e n . ” ) ;
         }
         p r i n t f ( ” Adios ! ” ) ;
         return 0 ;
}
Si au moment o` le test i == 0 est ´valu´, la valeur de i est bien 0, alors le test sera v´rifi´ et l’instruction
               u                   e     e                                                e e
printf("Vous avez saisi une valeur nullen.") sera bien ex´cut´e. Si le test n’est pas v´rifi´, les
                                                                      e e                              e e
instructions du bloc ... suivant le if sont ignor´es.
                                                  e




                                                         19
Si ... Alors ... Sinon
Il existe une forme ´tendue de traitement conditionnel, on la note en algorithmique de la fa¸on suivante :
                    e                                                                       c
    si condition alors
        instructions
    sinon
        autresinstructions
    fin

Les instructions d´limit´es par alors et sinon sont ex´cut´es si le test est v´rifi´, et les instructions
                  e     e                                e e                    e e
d´limit´es par sinon et finSi sont ex´cut´es si le test n’est pas v´rifi´. On traduit le traitement condi-
  e    e                             e e                           e e
tionnel ´tendu de la sorte :
        e
i f (< c o n d i t i o n >)
{
            <i n s t r u c t i o n s 1 >
}
else
{
            <i n s t r u c t i o n s 2 >
}
Par exemple,
#include<s t d i o . h>

int main ( )
{
         int i ;
         p r i n t f ( ” S a i s i s s e z une v a l e u r : ” ) ;
         s c a n f ( ”%d” , &i ) ;
         i f ( i == 0 )
         {
                         p r i n t f ( ”Vous avez s a i s i une v a l e u r n u l l e n . ” ) ;
         }
         else
         {
                         p r i n t f ( ”La v a l e u r que vous s a i s i , ”
                        ” a s a v o i r %d , n ’ e s t pas n u l l e .  n” , i ) ;
         }
         return 0 ;
}
Notez la pr´sence de l’op´rateur de comparaison ==. N’utilisez jamais = pour comparer deux va-
           e             e
leurs !.

Connecteurs logiques
On formule des conditions davantage ´labor´es en utilisant des connecteurs et et ou. La condition A et
                                       e      e
B est v´rifi´e si les deux conditions A et B sont v´rifi´es simultan´ment. La condition A ou B est v´rifi´e
       e e                                        e e             e                                  e e
si au moins une des deux conditions A et B est v´rifi´e. Le et s’´crit && et le ou s’´crit ||. Par exemple,
                                                  e e            e                  e
voici un programme C qui nous donne le signe de i × j sans les multiplier.
#include<s t d i o . h>

int main ( )
{
  int i , j ;


                                                         20
p r i n t f ( ” S a i s i s s e z deux v a l e u r s : ” ) ;
    s c a n f ( ”%d %d” , &i , &j ) ;
    p r i n t f ( ”Le p r o d u i t de c e s deux v a l e u r s e s t ” ) ;
    i f ( ( i < 0 && j < 0 ) | | ( i >= 0 && j>= 0 ) )
    {
      p r i n t f ( ” p o s i t i f n . ” ) ;
    }
    else
    {
      printf (” n´gatif ” ) ;
                        e
    }
    p r i n t f ( ” .  n” ) ;
    return 0 ;
}


Accolades superflues
Lorsqu’une seule instruction d’un bloc if doit ˆtre ex´cut´e, les accolades ne sont plus n´cessaires. Il est
                                               e      e e                                 e
possible par exemple de reformuler le programme pr´c´dent de la sorte :
                                                     e e
#include<s t d i o . h>

int main ( )
{
  int i , j ;
  p r i n t f ( ” S a i s i s s e z deux v a l e u r s : ” ) ;
  s c a n f ( ”%d %d” , &i , &j ) ;
  p r i n t f ( ”Le p r o d u i t de c e s deux v a l e u r s e s t ” ) ;
  i f ( ( i < 0 && j < 0 ) | | ( i >= 0 && j>= 0 ) )
    p r i n t f ( ” p o s i t i f n . ” ) ;
  else
    printf (” n´gatif ” ) ;
                      e
  p r i n t f ( ” .  n” ) ;
  return 0 ;
}


Op´rateur ternaire
  e
En pla¸ant l’instruction suivante ` droite d’une affectation,
      c                           a
<v a r i a b l e > = (< c o n d i t i o n >) ? <v a l e u r > : <a u t r e v a l e u r > ;
on place valeur dans variable si condition est v´rifi´, autrevaleur sinon. Par exemple,
                                                e e
max = ( i >j ) ? i : j ;
place la plus grande des deux valeurs i et j dans max. Plus g´n´ralement on peut utiliser le si ternaire
                                                             e e
dans n’importe quel calcul, par exemple
     p r i n t f ( ”%dn” , ( i > ( l = ( j >k ) ? j : k ) ) ? i : l ) ;
j = (j>k) ? j : k) place dans l la plus grande des valeurs j et k, donc (i > (l = (j > k) ? j :
k)) ? i : l est la plus grande des valeurs i, j et k. La plus grande de ces trois valeurs est donc affich´e
                                                                                                       e
par cette instruction.

1.4.2        Switch
Le switch en C s’´crit, avec la syntaxe suivante :
                 e


                                                             21
switch(< nomvariable >)
{
  case <v a l e u r 1 > : <i n s t r u c t i o n s 1 > ; break ;
  case <v a l e u r 2 > : <i n s t r u c t i o n s 2 > ; break ;
  /∗ . . . ∗/
  case <v a l e u r n > : <i n s t r u c t i o n s n > ; break ;
  default : /∗ i n s t r u c t i o n s ∗/
}
N’oubliez surtout pas les break ! Si par exemple, nous voulons afficher le nom d’un mois en fonction de
son num´ro, on ´crit
        e       e
switch ( numeroMois )
{
  case 1 : p r i n t f ( ” j a n v i e r ” ) ; break ;
  case 2 : p r i n t f ( ” f e v r i e r ” ) ; break ;
  case 3 : p r i n t f ( ” mars ” ) ; break ;
  case 4 : p r i n t f ( ” a v r i l ” ) ; break ;
  case 5 : p r i n t f ( ”mai” ) ; break ;
  case 6 : p r i n t f ( ” j u i n ” ) ; break ;
  case 7 : p r i n t f ( ” j u i l l e t ” ) ; break ;
  case 8 : p r i n t f ( ” aout ” ) ; break ;
  case 9 : p r i n t f ( ” septembre ” ) ; break ;
  case 10 : p r i n t f ( ” o c t o b r e ” ) ; break ;
  case 11 : p r i n t f ( ” novembre ” ) ; break ;
  case 12 : p r i n t f ( ” decembre ” ) ; break ;
  default : p r i n t f ( ” Je c o n n a i s pas c e mois . . . ” ) ;
}


1.4.3         Bool´ens
                  e
Une variable bool´enne ne peut prendre que deux valeurs : vrai et f aux. Il n’existe pas de type bool´en
                  e                                                                                      e
a
` proprement parler en C. On utilise des int pour simuler le comportement des bool´ens. On repr´sente
                                                                                        e             e
la valeur bool´enne f aux avec la valeur enti`re 0, toutes les autres valeurs enti`res servent ` repr´senter
              e                              e                                    e            a     e
vrai.

Utilisation dans des if
Lorsqu’une condition est ´valu´e, par exemple lors d’un test, cette condition prend ` ce moment la valeur
                            e    e                                                     a
vrai si le test est v´rifi´, f aux dans le cas contraire. La valeur enti`re 0 repr´sente la constante f aux et
                     e e                                               e         e
toutes les autres sont des constantes vrai. Observons le test suivant :
i f (8)
{
   // . . .
1 est un litt´ral de type entier dont le valeur est non nulle, donc il repr´sente le bool´en vrai. De ce fait,
             e                                                             e             e
le test if (8) est toujours v´rifi´. Par contre le test if (0) n’est jamais v´rifi´.
                               e e                                             e e

La valeur vrai
Mˆme si tout entier non nul a la valeur vrai, on prend par d´faut la valeur 1. Lorsqu’une condition est
  e                                                               e
´valu´e, elle prend la valeur 1 si elle est v´rifi´, 0 dans le cas contraire. par exemple,
e    e                                       e e
x = (3 >2);
On remarque que (3>2) est une condition. Pour d´cider quelle valeur doit ˆtre affect´e ` x, cette condition
                                                e                         e          e a
est ´valu´e. Comme dans l’exemple ci-dessus la condition est v´rifi´e, alors elle prend la valeur 1, et cette
    e    e                                                    e e
valeur est affect´e ` x.
                e a


                                                     22
Connecteurs logiques binaires
Les connecteurs || et && peuvent s’appliquer ` des valeurs (ou variables) enti`res. Observons l’exemple
                                             a                                e
suivant :
x = ( 3 && 0 ) | | ( 1 ) ;
Il s’agit de l’affectation ` x de l’´valuation de la condition (3 && 0) || (1). Comme 3 est vrai et 0 est
                          a        e
faux, alors leur conjonction est fausse. Donc (3 && 0) a pour valeur 0. La condition 0 || 1 est ensuite
´valu´e et prend la valeur vrai. Donc la valeur 1 est affect´e ` x.
e     e                                                      e a

Op´rateur de n´gation
  e           e
Parmi les connecteurs logiques se trouve !, dit op´rateur de n´gation. La n´gation d’une expression est
                                                       e            e            e
vraie si l’expression est fausse, fausse si l’expression est vraie. Par exemple,
x = !(3==2);
Comme 3 == 2 est faux, alors sa n´gation !(3 == 2) est vraie. Donc la valeur 1 est affect´e ` x.
                                 e                                                      e a

1.4.4     Les priorit´s
                     e
Compl`tons notre tableau
       e                     des priorit´s en y adjoignant les connecteurs logiques et les op´rateurs de
                                        e                                                    e
comparaison :
    noms                     op´rateurs
                                e
    op´rateurs unaires
        e                    cast, -, ~, !, ++, --
    produit                  *, /, %
    somme                    +, -
    d´calage binaire
      e                      >>, <<
    comparaison              >, <, >=, <=
    ´galit´
    e     e                  ==, !=
    ET binaire               &
    OU Exlusif binaire       ^
    OU binaire               |
    connecteurs logiques     &&, ||
    if ternaire              () ? :
    affectations              =, +=, -=, . . .

1.4.5     Pr´processeur
            e
Macro-instructions
Le C nous permet de placer ` peu pr`s n’importe quoi dans les constantes. Si par exemple, on est lass´
                              a        e                                                             e
d’´crire des instructions de retour ` la ligne, il suffit de d´finir
  e                                 a                       e
#define RC p r i n t f ( ”n” )
Dans ce cas, toutes les occurrences de RC dans le code seront remplac´es par des printf("n"). Par
                                                                     e
exemple
#include<s t d i o . h>

#define BEGIN {
#define END }

#define    RC p r i n t f ( ”n” )
#define    AFFICHE DEBUT p r i n t f ( ”Debut” )
#define    AFFICHE FIN p r i n t f ( ” Fin ” )
#define    AFFICHE MLILIEU p r i n t f ( ” M i l i e u ” )


                                                      23
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c
Langage c

Contenu connexe

Tendances

Caterpillar cat ec55 n forklift lift trucks service repair manual sna2ec5 602...
Caterpillar cat ec55 n forklift lift trucks service repair manual sna2ec5 602...Caterpillar cat ec55 n forklift lift trucks service repair manual sna2ec5 602...
Caterpillar cat ec55 n forklift lift trucks service repair manual sna2ec5 602...
fjskekdmmse
 
Trouver un Emploi à plus de 45 ans
Trouver un Emploi à plus de 45 ansTrouver un Emploi à plus de 45 ans
Trouver un Emploi à plus de 45 ans
REALIZ
 
PMP Report
PMP ReportPMP Report
PMP Report
Caner Candan
 
oecoil condens-2-notice-utilisation
oecoil condens-2-notice-utilisationoecoil condens-2-notice-utilisation
oecoil condens-2-notice-utilisation
ClothildeBenares
 
The Ring programming language version 1.6 book - Part 1 of 189
The Ring programming language version 1.6 book - Part 1 of 189The Ring programming language version 1.6 book - Part 1 of 189
The Ring programming language version 1.6 book - Part 1 of 189
Mahmoud Samir Fayed
 
Media file 8531
Media file 8531Media file 8531
Media file 8531
alia daoud
 
Manuel du module additionnel RF-LAMINATE pour RFEM
Manuel du module additionnel RF-LAMINATE pour RFEMManuel du module additionnel RF-LAMINATE pour RFEM
Manuel du module additionnel RF-LAMINATE pour RFEM
Grégoire Dupont
 
The Ring programming language version 1.5.2 book - Part 1 of 181
The Ring programming language version 1.5.2 book - Part 1 of 181The Ring programming language version 1.5.2 book - Part 1 of 181
The Ring programming language version 1.5.2 book - Part 1 of 181
Mahmoud Samir Fayed
 
Ing ordre generique_tpv_serveur 0.8
Ing ordre generique_tpv_serveur 0.8Ing ordre generique_tpv_serveur 0.8
Ing ordre generique_tpv_serveur 0.8
Lokesh Kumar
 
Instruction Manual | Celestron LCM Telescopes | Optics Trade
Instruction Manual | Celestron LCM Telescopes | Optics TradeInstruction Manual | Celestron LCM Telescopes | Optics Trade
Instruction Manual | Celestron LCM Telescopes | Optics Trade
Optics-Trade
 
Analyse2 00
Analyse2 00Analyse2 00
Analyse2 00
Oussama Lahssini
 
Instruction Manual | Celestron AstroMaster EQ | Telescopes | Optics Trade
Instruction Manual | Celestron AstroMaster EQ | Telescopes | Optics TradeInstruction Manual | Celestron AstroMaster EQ | Telescopes | Optics Trade
Instruction Manual | Celestron AstroMaster EQ | Telescopes | Optics Trade
Optics-Trade
 
Exemple de proposition PME Permabec
Exemple de proposition PME PermabecExemple de proposition PME Permabec
Exemple de proposition PME Permabec
Carl Bilodeau
 
Cours processus- production
Cours processus- productionCours processus- production
Cours processus- production
Amine Chahed
 
Analysis of the situation of children's residential institutions in the Kyrgy...
Analysis of the situation of children's residential institutions in the Kyrgy...Analysis of the situation of children's residential institutions in the Kyrgy...
Analysis of the situation of children's residential institutions in the Kyrgy...
UNICEF Europe & Central Asia
 
Ergonomie
ErgonomieErgonomie
Ergonomie
Cedric Blupan
 
Annexes Logiciel Pl7
Annexes Logiciel Pl7Annexes Logiciel Pl7
Annexes Logiciel Pl7
youri59490
 

Tendances (20)

Caterpillar cat ec55 n forklift lift trucks service repair manual sna2ec5 602...
Caterpillar cat ec55 n forklift lift trucks service repair manual sna2ec5 602...Caterpillar cat ec55 n forklift lift trucks service repair manual sna2ec5 602...
Caterpillar cat ec55 n forklift lift trucks service repair manual sna2ec5 602...
 
Trouver un Emploi à plus de 45 ans
Trouver un Emploi à plus de 45 ansTrouver un Emploi à plus de 45 ans
Trouver un Emploi à plus de 45 ans
 
Ids
IdsIds
Ids
 
PMP Report
PMP ReportPMP Report
PMP Report
 
TCB
TCBTCB
TCB
 
oecoil condens-2-notice-utilisation
oecoil condens-2-notice-utilisationoecoil condens-2-notice-utilisation
oecoil condens-2-notice-utilisation
 
Mmc
MmcMmc
Mmc
 
The Ring programming language version 1.6 book - Part 1 of 189
The Ring programming language version 1.6 book - Part 1 of 189The Ring programming language version 1.6 book - Part 1 of 189
The Ring programming language version 1.6 book - Part 1 of 189
 
Media file 8531
Media file 8531Media file 8531
Media file 8531
 
Manuel du module additionnel RF-LAMINATE pour RFEM
Manuel du module additionnel RF-LAMINATE pour RFEMManuel du module additionnel RF-LAMINATE pour RFEM
Manuel du module additionnel RF-LAMINATE pour RFEM
 
The Ring programming language version 1.5.2 book - Part 1 of 181
The Ring programming language version 1.5.2 book - Part 1 of 181The Ring programming language version 1.5.2 book - Part 1 of 181
The Ring programming language version 1.5.2 book - Part 1 of 181
 
Ing ordre generique_tpv_serveur 0.8
Ing ordre generique_tpv_serveur 0.8Ing ordre generique_tpv_serveur 0.8
Ing ordre generique_tpv_serveur 0.8
 
Instruction Manual | Celestron LCM Telescopes | Optics Trade
Instruction Manual | Celestron LCM Telescopes | Optics TradeInstruction Manual | Celestron LCM Telescopes | Optics Trade
Instruction Manual | Celestron LCM Telescopes | Optics Trade
 
Analyse2 00
Analyse2 00Analyse2 00
Analyse2 00
 
Instruction Manual | Celestron AstroMaster EQ | Telescopes | Optics Trade
Instruction Manual | Celestron AstroMaster EQ | Telescopes | Optics TradeInstruction Manual | Celestron AstroMaster EQ | Telescopes | Optics Trade
Instruction Manual | Celestron AstroMaster EQ | Telescopes | Optics Trade
 
Exemple de proposition PME Permabec
Exemple de proposition PME PermabecExemple de proposition PME Permabec
Exemple de proposition PME Permabec
 
Cours processus- production
Cours processus- productionCours processus- production
Cours processus- production
 
Analysis of the situation of children's residential institutions in the Kyrgy...
Analysis of the situation of children's residential institutions in the Kyrgy...Analysis of the situation of children's residential institutions in the Kyrgy...
Analysis of the situation of children's residential institutions in the Kyrgy...
 
Ergonomie
ErgonomieErgonomie
Ergonomie
 
Annexes Logiciel Pl7
Annexes Logiciel Pl7Annexes Logiciel Pl7
Annexes Logiciel Pl7
 

En vedette

Weos routage dynamique OSPF
Weos routage dynamique OSPFWeos routage dynamique OSPF
Weos routage dynamique OSPF
Fabian Vandendyck
 
Anna hernandez
Anna hernandezAnna hernandez
Anna hernandez
laieneblog
 
Anuncios grandes causas
Anuncios grandes causasAnuncios grandes causas
Anuncios grandes causas
laieneblog
 
Semana 4 periodico
Semana 4 periodicoSemana 4 periodico
Semana 4 periodico
Jose Ramon Macias Ballestero
 
Noticia
NoticiaNoticia
Projet carrieère
Projet carrieèreProjet carrieère
Projet carrieère
chansavo12
 
Projet carriére
Projet carriéreProjet carriére
Projet carriére
yilme
 
Taller integral de internet
Taller integral de internetTaller integral de internet
Taller integral de internet
Fernanda Lizeth
 
Ordesa y Monte Perdido (Jonathan Lebrón y Santiago Manrique)
Ordesa y Monte Perdido  (Jonathan Lebrón y Santiago Manrique)Ordesa y Monte Perdido  (Jonathan Lebrón y Santiago Manrique)
Ordesa y Monte Perdido (Jonathan Lebrón y Santiago Manrique)
Juan Diego Peñas
 
Zafra
ZafraZafra
Le diagnostic numérique de Sens et du Sénonais
Le diagnostic numérique de Sens et du SénonaisLe diagnostic numérique de Sens et du Sénonais
Le diagnostic numérique de Sens et du Sénonais
Tourisme Sens
 
Trasplantes
TrasplantesTrasplantes
Diapositivas
DiapositivasDiapositivas
Diapositivas
Marce Forero
 
Monfragüe (Sandra Morillo y Marta Bermejo)
Monfragüe (Sandra Morillo y Marta Bermejo)Monfragüe (Sandra Morillo y Marta Bermejo)
Monfragüe (Sandra Morillo y Marta Bermejo)
Juan Diego Peñas
 

En vedette (17)

Weos routage dynamique OSPF
Weos routage dynamique OSPFWeos routage dynamique OSPF
Weos routage dynamique OSPF
 
Anna hernandez
Anna hernandezAnna hernandez
Anna hernandez
 
Anuncios grandes causas
Anuncios grandes causasAnuncios grandes causas
Anuncios grandes causas
 
Semana 4 periodico
Semana 4 periodicoSemana 4 periodico
Semana 4 periodico
 
Présentation1
Présentation1Présentation1
Présentation1
 
Noticia
NoticiaNoticia
Noticia
 
Projet carrieère
Projet carrieèreProjet carrieère
Projet carrieère
 
Projet carriére
Projet carriéreProjet carriére
Projet carriére
 
Taller integral de internet
Taller integral de internetTaller integral de internet
Taller integral de internet
 
Ordesa y Monte Perdido (Jonathan Lebrón y Santiago Manrique)
Ordesa y Monte Perdido  (Jonathan Lebrón y Santiago Manrique)Ordesa y Monte Perdido  (Jonathan Lebrón y Santiago Manrique)
Ordesa y Monte Perdido (Jonathan Lebrón y Santiago Manrique)
 
Zafra
ZafraZafra
Zafra
 
Le diagnostic numérique de Sens et du Sénonais
Le diagnostic numérique de Sens et du SénonaisLe diagnostic numérique de Sens et du Sénonais
Le diagnostic numérique de Sens et du Sénonais
 
Trasplantes
TrasplantesTrasplantes
Trasplantes
 
Diapositivas
DiapositivasDiapositivas
Diapositivas
 
Bon anniversaire thibaut
Bon anniversaire thibautBon anniversaire thibaut
Bon anniversaire thibaut
 
Monfragüe (Sandra Morillo y Marta Bermejo)
Monfragüe (Sandra Morillo y Marta Bermejo)Monfragüe (Sandra Morillo y Marta Bermejo)
Monfragüe (Sandra Morillo y Marta Bermejo)
 
Emplois
EmploisEmplois
Emplois
 

Similaire à Langage c

Polycope java enseignant
Polycope java enseignantPolycope java enseignant
Polycope java enseignant
hnsfr
 
Cours mecasol 0_2
Cours mecasol 0_2Cours mecasol 0_2
Cours mecasol 0_2
kahinarouam
 
courspython3.pdf
courspython3.pdfcourspython3.pdf
courspython3.pdf
Dendouga1
 
Crown tsp6000 series turret order picker service repair manual
Crown tsp6000 series turret order picker service repair manualCrown tsp6000 series turret order picker service repair manual
Crown tsp6000 series turret order picker service repair manual
jfksekmmdme
 
Crown tsp6000 series turret order picker service repair manual
Crown tsp6000 series turret order picker service repair manualCrown tsp6000 series turret order picker service repair manual
Crown tsp6000 series turret order picker service repair manual
fhhsjdkmem
 
Crown tsp6000 series turret order picker service repair manual
Crown tsp6000 series turret order picker service repair manualCrown tsp6000 series turret order picker service repair manual
Crown tsp6000 series turret order picker service repair manual
udjdkdkdmm
 
Report MyProof
Report MyProofReport MyProof
Report MyProof
Caner Candan
 
Giao trinh quang hoc.1089003
Giao trinh quang hoc.1089003Giao trinh quang hoc.1089003
Giao trinh quang hoc.1089003
Phi Phi
 
Cours de-finance
Cours de-financeCours de-finance
Cours de-finance
Akobe Jean Stanislas Akobe
 
The Ring programming language version 1.8 book - Part 1 of 202
The Ring programming language version 1.8 book - Part 1 of 202The Ring programming language version 1.8 book - Part 1 of 202
The Ring programming language version 1.8 book - Part 1 of 202
Mahmoud Samir Fayed
 
Extrait ouvrage 65_outils_du_changement_arnaud_tonnele
Extrait ouvrage 65_outils_du_changement_arnaud_tonneleExtrait ouvrage 65_outils_du_changement_arnaud_tonnele
Extrait ouvrage 65_outils_du_changement_arnaud_tonnele
Sandra Santana
 
The Ring programming language version 1.7 book - Part 1 of 196
The Ring programming language version 1.7 book - Part 1 of 196The Ring programming language version 1.7 book - Part 1 of 196
The Ring programming language version 1.7 book - Part 1 of 196
Mahmoud Samir Fayed
 
Cours statistique descriptive
Cours statistique descriptiveCours statistique descriptive
Cours statistique descriptive
Mouna Ettahiri
 
8.02 introduction to electrodynamics 3e-griffiths
8.02 introduction to electrodynamics 3e-griffiths8.02 introduction to electrodynamics 3e-griffiths
8.02 introduction to electrodynamics 3e-griffiths
prefeitura municipal de araraquara
 
Guide projet Iset
Guide projet IsetGuide projet Iset
Guide projet Iset
Habib M'henni
 
The Ring programming language version 1.3 book - Part 1 of 88
The Ring programming language version 1.3 book - Part 1 of 88The Ring programming language version 1.3 book - Part 1 of 88
The Ring programming language version 1.3 book - Part 1 of 88
Mahmoud Samir Fayed
 
Deviens un Ninja avec Angular2
Deviens un Ninja avec Angular2Deviens un Ninja avec Angular2
Deviens un Ninja avec Angular2
Gantner Technologies
 

Similaire à Langage c (20)

Analyse s1
Analyse s1Analyse s1
Analyse s1
 
Polycope java enseignant
Polycope java enseignantPolycope java enseignant
Polycope java enseignant
 
Cours mecasol 0_2
Cours mecasol 0_2Cours mecasol 0_2
Cours mecasol 0_2
 
courspython3.pdf
courspython3.pdfcourspython3.pdf
courspython3.pdf
 
Crown tsp6000 series turret order picker service repair manual
Crown tsp6000 series turret order picker service repair manualCrown tsp6000 series turret order picker service repair manual
Crown tsp6000 series turret order picker service repair manual
 
Crown tsp6000 series turret order picker service repair manual
Crown tsp6000 series turret order picker service repair manualCrown tsp6000 series turret order picker service repair manual
Crown tsp6000 series turret order picker service repair manual
 
Crown tsp6000 series turret order picker service repair manual
Crown tsp6000 series turret order picker service repair manualCrown tsp6000 series turret order picker service repair manual
Crown tsp6000 series turret order picker service repair manual
 
Manuel 3
Manuel 3Manuel 3
Manuel 3
 
Report MyProof
Report MyProofReport MyProof
Report MyProof
 
Giao trinh quang hoc.1089003
Giao trinh quang hoc.1089003Giao trinh quang hoc.1089003
Giao trinh quang hoc.1089003
 
Cours de-finance
Cours de-financeCours de-finance
Cours de-finance
 
The Ring programming language version 1.8 book - Part 1 of 202
The Ring programming language version 1.8 book - Part 1 of 202The Ring programming language version 1.8 book - Part 1 of 202
The Ring programming language version 1.8 book - Part 1 of 202
 
Extrait ouvrage 65_outils_du_changement_arnaud_tonnele
Extrait ouvrage 65_outils_du_changement_arnaud_tonneleExtrait ouvrage 65_outils_du_changement_arnaud_tonnele
Extrait ouvrage 65_outils_du_changement_arnaud_tonnele
 
The Ring programming language version 1.7 book - Part 1 of 196
The Ring programming language version 1.7 book - Part 1 of 196The Ring programming language version 1.7 book - Part 1 of 196
The Ring programming language version 1.7 book - Part 1 of 196
 
Cours statistique descriptive
Cours statistique descriptiveCours statistique descriptive
Cours statistique descriptive
 
8.02 introduction to electrodynamics 3e-griffiths
8.02 introduction to electrodynamics 3e-griffiths8.02 introduction to electrodynamics 3e-griffiths
8.02 introduction to electrodynamics 3e-griffiths
 
Nagios
NagiosNagios
Nagios
 
Guide projet Iset
Guide projet IsetGuide projet Iset
Guide projet Iset
 
The Ring programming language version 1.3 book - Part 1 of 88
The Ring programming language version 1.3 book - Part 1 of 88The Ring programming language version 1.3 book - Part 1 of 88
The Ring programming language version 1.3 book - Part 1 of 88
 
Deviens un Ninja avec Angular2
Deviens un Ninja avec Angular2Deviens un Ninja avec Angular2
Deviens un Ninja avec Angular2
 

Langage c

  • 1. Initiation au Langage C Alexandre Mesl´ e 16 juin 2009
  • 2. Table des mati`res e 1 Notes de cours 6 1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 1.1.1 D´finitions et terminologie . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 1.1.2 Hello World ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 1.1.3 Structure d’un programme C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 1.1.4 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 1.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 1.2.1 D´claration . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 1.2.2 Affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 1.2.3 Saisie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 1.2.4 Affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 1.2.5 Entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 1.2.6 Flottants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 1.2.7 Caract`res . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 1.2.8 Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 1.3 Op´rateurs . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 1.3.1 G´n´ralit´s . . . . . . . . . . e e e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 1.3.2 Les op´rateurs unaires . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 1.3.3 Les op´rateurs binaires . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 1.3.4 Formes contract´es . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 1.3.5 Op´rations h´t´rog`nes . . . e ee e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 1.3.6 Les priorit´s . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 1.4 Traitements conditionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 1.4.1 Si ... Alors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 1.4.2 Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 1.4.3 Bool´ens . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 1.4.4 Les priorit´s . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 1.4.5 Pr´processeur . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 1.5 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 1.5.1 D´finitions et terminologie . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 1.5.2 while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 1.5.3 do ... while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 1.5.4 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 1.5.5 Accolades superflues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 1.6 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 1.6.1 D´finitions . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 1.6.2 D´claration . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 1.6.3 Initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 1.6.4 Acc`s aux ´l´ments . . . . . . e ee . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 1.6.5 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 1.7 Chaˆ ınes de caract`res . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 1.7.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 1.7.2 D´finition . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 1
  • 3. 1.7.3 D´claration . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . 32 1.7.4 Initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 1.7.5 Acc`s aux ´l´ments . . . . . . . . . . e ee . . . . . . . . . . . . . . . . . . . . . . . . . . 33 1.7.6 Affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 1.7.7 Saisie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 1.7.8 Probl`mes li´s ` la saisie bufferis´e . e e a e . . . . . . . . . . . . . . . . . . . . . . . . . . 35 1.7.9 La biblioth`que string.h . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . 35 1.7.10 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 1.8 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 1.8.1 Les proc´dures . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . 37 1.8.2 Variables locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 1.8.3 Passage de param`tres . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . 40 1.8.4 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 1.8.5 Passages de param`tre par r´f´rence e ee . . . . . . . . . . . . . . . . . . . . . . . . . . 44 1.9 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 1.9.1 D´finition . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . 45 1.9.2 D´claration . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . 45 1.9.3 Acc`s aux champs . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . 45 1.9.4 Typedef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 1.9.5 Tableaux de structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 1.9.6 Structures et fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 1.10 Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 1.10.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 1.10.2 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 1.10.3 Allocation dynamique de la m´moire e . . . . . . . . . . . . . . . . . . . . . . . . . . 55 1.10.4 Passage de param`tres par r´f´rence e ee . . . . . . . . . . . . . . . . . . . . . . . . . . 58 1.10.5 Pointeurs sur fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 1.11 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 1.11.1 D´finitions . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . 61 1.11.2 Ouverture et fermeture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 1.11.3 Lecture et ´criture . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . 62 1.12 Listes Chaˆ ees . . . . . . . . . . . . . . . . ın´ . . . . . . . . . . . . . . . . . . . . . . . . . . 65 1.12.1 Le probl`me . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . 65 1.12.2 Pointeurs et structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 1.12.3 Un premier exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 1.12.4 Le chaˆ ınage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 1.12.5 Utilisation de malloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 1.12.6 Op´rations . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . 74 1.12.7 Listes doublement chaˆ ees . . . . . ın´ . . . . . . . . . . . . . . . . . . . . . . . . . . 74 2 Exercices 76 2.1 Variables et op´rateurs . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 2.1.1 Entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 2.1.2 Flottants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 2.1.3 Caract`res . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 2.1.4 Op´rations sur les bits (difficiles) e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 2.1.5 Morceaux choisis (difficiles) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 2.2 Traitements conditionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 2.2.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 2.2.2 Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 2.2.3 L’´chiquier . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 2.2.4 Heures et dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 2.2.5 Intervalles et rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 2.2.6 Pr´processeur . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 2.2.7 Nombres et lettres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 2
  • 4. 2.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 2.3.1 Compr´hension . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . 84 2.3.2 Utilisation de toutes les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 2.3.3 Choix de la boucle la plus appropri´e e . . . . . . . . . . . . . . . . . . . . . . . . . 85 2.3.4 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 2.3.5 Extension de la calculatrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 2.4 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 2.4.1 Exercices de compr´hension . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . 88 2.4.2 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 2.4.3 Indices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 2.4.4 Recherche s´quentielle . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . 89 2.4.5 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 2.5 Chaˆ ınes de caract`res . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . 91 2.5.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 2.5.2 Les fonctions de string.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 2.5.3 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 2.6 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 2.6.1 G´om´trie . . . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . . . . . . . . . . . . 93 2.6.2 Arithm´tique . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . 95 2.6.3 Passage de tableaux en param`tre . . e . . . . . . . . . . . . . . . . . . . . . . . . . 96 2.6.4 D´composition en facteurs premiers . e . . . . . . . . . . . . . . . . . . . . . . . . . 97 2.6.5 Statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 2.6.6 Chaˆ ınes de caract`res . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . 99 2.6.7 Programmation d’un Pendu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 2.6.8 Tris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 2.7 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 2.7.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 2.7.2 Heures de la journ´e . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . 101 2.7.3 R´pertoire t´l´phonique . . . . . . . . e ee . . . . . . . . . . . . . . . . . . . . . . . . . 103 2.8 Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 2.8.1 Aliasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 2.8.2 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 2.8.3 Exercices sans sous-programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 2.8.4 Allocation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 2.8.5 Pointeurs et pointeurs de pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 2.8.6 Passages de param`tres par r´f´rence . e ee . . . . . . . . . . . . . . . . . . . . . . . . . 106 2.8.7 Les pointeurs sans ´toile . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . 107 2.8.8 Tableau de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 2.8.9 Triangle de Pascal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 2.8.10 Pointeurs et r´cursivit´ . . . . . . . . e e . . . . . . . . . . . . . . . . . . . . . . . . . 108 2.8.11 Tri fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 2.9 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 2.9.1 Ouverture et fermeture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 2.9.2 Lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 2.9.3 Ecriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 2.9.4 Lecture et ´criture . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . 112 2.9.5 Enigma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 2.10 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 2.11 Listes Chaˆ ees . . . . . . . . . . . . . . . . . ın´ . . . . . . . . . . . . . . . . . . . . . . . . . 118 2.11.1 Pointeurs et structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 2.11.2 Maniement du chaˆ ınage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 2.11.3 Op´rations sur les listes chaˆ ees . . . e ın´ . . . . . . . . . . . . . . . . . . . . . . . . . 120 2.11.4 Listes doublement chaˆ ees . . . . . . ın´ . . . . . . . . . . . . . . . . . . . . . . . . . 120 2.11.5 Fonctions r´cursives et listes chaˆ ees e ın´ . . . . . . . . . . . . . . . . . . . . . . . . . 121 3
  • 5. A Quelques corrig´s e 124 A.1 Variables et op´rateurs . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . 124 A.1.1 Entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 A.1.2 Flottants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 A.1.3 Caract`res . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . 126 A.1.4 Op´rations binaires . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . 127 A.1.5 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 A.2 Traitements conditionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 A.2.1 Prise en Main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 A.2.2 Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 A.2.3 Heures et dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 A.2.4 Echiquier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 A.2.5 Intervalles et rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 A.2.6 Nombres et lettres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 A.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 A.3.1 Utilisation de toutes les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 A.3.2 Choix de la boucle la plus appropri´e . . . e . . . . . . . . . . . . . . . . . . . . . . 142 A.3.3 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 A.4 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 A.4.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 A.4.2 Indices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 A.4.3 Recherche s´quentielle . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . 147 A.4.4 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 A.5 Chaˆ ınes de caract`res . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . 151 A.5.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 A.5.2 Les fonctions de string.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 A.5.3 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 A.6 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 A.6.1 G´om´trie . . . . . . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . . . . . . . . . 154 A.6.2 Arithm´tique . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . 156 A.6.3 Passage de tableaux en param`tre . . . . . e . . . . . . . . . . . . . . . . . . . . . . 158 A.6.4 D´composition en facteurs premiers . . . . e . . . . . . . . . . . . . . . . . . . . . . 159 A.6.5 Statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 A.6.6 Chaines de caract`res . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . 161 A.6.7 Programmation d’un pendu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162 A.6.8 Tris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 A.7 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 A.7.1 Heures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 A.7.2 R´pertoire t´l´phonique . . . . . . . . . . . e ee . . . . . . . . . . . . . . . . . . . . . . 166 A.8 Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170 A.8.1 Exercices sans sous-programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170 A.8.2 Pointeurs sans ´toiles et triangle de Pascal . e . . . . . . . . . . . . . . . . . . . . . . 171 A.8.3 Fonctions r´cursives . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . 173 A.8.4 Tri fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 A.9 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 A.9.1 Ouverture et fermeture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 A.9.2 Lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 A.9.3 Ecriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 A.9.4 Lecture et ´criture . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . 182 A.10 Listes Chaˆ ees . . . . . . . . . . . . . . . . . . . . ın´ . . . . . . . . . . . . . . . . . . . . . . 184 A.10.1 Pointeurs et structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 A.10.2 Maniement du chaˆ ınage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 A.10.3 Listes doublement chaˆ ees . . . . . . . . . ın´ . . . . . . . . . . . . . . . . . . . . . . 187 A.10.4 Fonctions r´cursives et listes chaˆ ees . . . e ın´ . . . . . . . . . . . . . . . . . . . . . . 190 4
  • 6. B Projets 194 B.1 Agenda (pour les PPAs) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 A M´thodologie e 195 A.1 Le probl`me . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 A.2 Les r`gles d’or . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 A.2.1 G´n´ralit´s . . . . . . . . . . e e e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 A.2.2 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 A.2.3 Compilation s´par´e . . . . . e e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 A.3 D´bogage . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 A.4 Dur´e de vie du code . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 A.4.1 Le code doit ˆtre r´utilisable e e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 A.4.2 Le code doit ˆtre adaptable . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 A.5 Exemple : le carnet de contacts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 A.5.1 util.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 A.5.2 util.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 A.5.3 tableau.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198 A.5.4 tableau.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199 A.5.5 eMails.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 A.5.6 makefile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204 5
  • 7. Chapitre 1 Notes de cours 1.1 Introduction 1.1.1 D´finitions et terminologie e Un programme ex´cutable est une suite d’instructions ex´cut´e par le processeur. Ces instructions sont e e e tr`s difficile ` comprendre, si par exemple, vous ouvrez avec un ´diteur de texte (notepad, emacs, etc) un e a e fichier ex´cutable, vous verrez s’afficher un charabia incompr´hensible : e e 00000000 0000001f 0000003e 0000005d 0000007c 0000009b 000000ba 000000d9 000000f8 00000117 00000136 00000155 00000174 00000193 000001b2 000001d1 000001f0 0000020f 0000022e 0000024d 0000026c 0000028b 000002aa 000002c9 000002e8 00000307 ... Il n’est pas envisageable de cr´er des programmes en ´crivant des suites de chiffres et de lettres. Nous e e allons donc utiliser des langages de programmation pour ce faire. Un programme C est un ensemble d’instructions qui se saisit dans un fichier .c ` l’aide d’un ´diteur a e 6
  • 8. (ex. : Notepad), ce type de fichier s’appelle une source. Les instructions qui y sont ´crites s’appellent e du code ou encore le code source. Un compilateur est un logiciel qui lit le code source et le convertit en un code ex´cutable, c’est-`-dire un ensemble d’instructions compr´hensible par le processeur. La e a e compilation d’une source se fait en deux ´tapes : la compilation proprement dite et le linkage. On utilise e en g´n´ral le terme compilation en englobant les deux ´tapes pr´c´demment cit´es. e e e e e e – La compilation ` proprement parler produit un fichier objet, dont l’extension est .obj. a – Les sources peuvent ˆtre r´parties dans plusieurs fichiers, ceux-ci doivent tous ˆtre compil´s s´par´ment. e e e e e e Ensuite, le linkage des diff´rents fichiers objets est assemblage produisant un ex´cutable .exe. e e Certains environnement de d´veloppement servent d’´diteur, et prennent en charge la compilation et le e e linkage (eclipse, dev-C++). 1.1.2 Hello World ! Allez sur http://www.01net.com/telecharger/windows/Programmation/langage/fiches/2327.html, cliquez sur t´l´charger. Installez Dev-C++. Ouvrez un nouveau fichier source. Copiez-collez le code ci- ee dessous dans l’´diteur : e #include<s t d i o . h> #include<c o n i o . h> int main ( ) { p r i n t f ( ” H e l l o World ! n” ) ; getch ( ) ; return 0 ; } Sauvegardez ce fichier sous le nom helloWorld.c. Dans le menu Ex´cuter, cliquez sur Compiler. Remar- e quez que la compilation a produit un fichier helloWorld.exe. Vous avez deux fa¸ons de l’ex´cuter : c e – double-cliquez directement sur helloWorld.exe – Dans le menu Ex´cuter, cliquez sur ex´cuter. e e 1.1.3 Structure d’un programme C Importation des biblioth`ques e #include<s t d i o . h> #include<c o n i o . h> Selon ce que l’on souhaite faire dans notre programme, on peut avoir besoin de diff´rentes fonctions. e Celles-ci sont disponibles dans des biblioth`ques. Par exemple : e – stdio.h propose des fonctions de saisie et d’affichage – conio.h propose d’autre fonctions d’entr´es-sorties e Corps du programme int main ( ) { p r i n t f ( ” H e l l o world ! ” ) ; getch ( ) ; return 0 ; } On place dans les accolades du main les instructions que l’on souhaite voir s’ex´cuter : e int main ( ) { 7
  • 9. <i n s t r u c t i o n s A E x e c u t e r > return 0 ; } Remarquez que chaque ligne se termine par un points-virgule. Pour afficher une variable de type apha- num´rique en C, on utilise printf(<valeur ` afficher>) ;. Les litt´raux de type alphanum´riques en e a e e C s’´crivent entre doubles quotes. getch() ; nous sert ` suspendre l’ex´cution du programme jusqu’` ce e a e a que l’utilisateur appuie sur une touche. 1.1.4 Commentaires Un commentaire est une s´quence de caract`res ignor´e par le compilateur, on s’en sert pour expliquer e e e des portions de code. Alors ayez une pens´e pour les pauvres programmeurs qui vont reprendre votre e code apr`s vous, le pauvre correcteur qui va essayer de comprendre votre pens´e profonde, ou bien plus e e simplement ` vous-mˆme au bout de six mois, quand vous aurez compl`tement oubli´ ce que vous aviez a e e e dans la tˆte en codant. On d´limite un commentaire par /* et */. Par exemple, e e int main ( ) { /∗ Ceci e s t un commentaire : L ’ i n s t r u c t i o n c i −d e s s o u s a f f i c h e ’ ’ H e l l o morld ! ’ ’ Ces p h r a s e s s o n t i g n o r ´ e s par l e c o m p i l a t e u r . e ∗/ p r i n t f ( ” H e l l o world ! n” ) ; return 0 ; } 8
  • 10. 1.2 Variables Une variable est un emplacement de la m´moire dans lequel est stock´e une valeur. Chaque variable porte e e une nom et c’est ce nom qui sert ` identifi´ l’emplacement de la m´moire repr´sent´ par cette variable. a e e e e Pour utiliser une variable, la premi`re ´tape est la d´claration. e e e 1.2.1 D´claration e D´clarer une variable, c’est pr´venir le compilateur qu’un nom va ˆtre utilis´ pour d´signer un emplace- e e e e e ment de la m´moire. En C, on d´clare les variables juste apr`s l’accolade suivant main() (pour le moment). e e e On place les instructions ` ex´cuter ` la suite de la d´claration de variables. a e a e main ( ) { <d e c l a r a t i o n de v a r i a b l e s > <i n s t r u c t i o n s a executer > } Nous ne travaillerons pour le moment que sur les variables de type num´rique entier. Le type qui y e correspond, en C, est int. On d´clare les variables enti`res de la mani`re suivante : e e e int <v a r 1 >, <v a r 2 >, . . . , <var n >; Cette instruction d´clare les variables var 1, var 2, ..., var n de type entier. Par exemple, e #include<s t d i o . h> int main ( ) { int v a r i a b l e 1 , v a r i a b l e 2 ; int a u t r e v a r i a b l e 1 , a u t r e v a r i a b l e 2 ; return 0 ; } On appelle bloc le contenu des accolades du main. 1.2.2 Affectation Si on souhaite affecter ` la variable v une valeur, on utilise l’op´rateur =. Par exemple, a e int main ( ) { int v ; v = 5; return 0 ; } Ce programme d´clare une variable de type entier que l’on appelle v, puis lui affecte la valeur 5. Comme e vous venez de le voir, il est possible d’´crire directement dans le code une valeur que l’on donne ` une e a variable. Notez l’abscence de include, ce programme n’effectue aucune entr´e-sortie, il n’est donc pas e n´cessaire d’importer les biblioth`ques d’entr´es/sorties. e e e Les op´rations arihm´tiques disponibles sont l’addition (+), la soustraction (-), la multiplication (*), e e la division enti`re dans l’ensemble des entiers relatifs (quotient : /, reste : %). e int main ( ) { int v , w, z ; v = 5; w = v + 1; 9
  • 11. z = v + w / 2; v = z % 3; v = v ∗ 2; return 0 ; } 1.2.3 Saisie Traduisons en C l’instruction Saisir <variable> que nous avons vu en algorithmique. Pour r´cup´rer e e la saisie d’un utilisateur et la placer dans une variable <variable>, on utilise l’instruction suivante : s c a n f ( ”%d” , &<v a r i a b l e >); scanf suspend l’ex´cution du programme jusqu’` ce que l’utilisateur ait saisi une valeur et press´ la e a e touche return. La valeur saisie est alors affet´e ` la variable <variable>. N’oubliez surtout pas le &, e a sinon des choses absurdes pourraient se produire ! 1.2.4 Affichage Traduisons maintenant l’instruction Afficher variable en C. Cette instruction permet d’afficher la valeur d’une variable. p r i n t f ( ”%d” , <v a r i a b l e >); Cette instruction affiche la valeur contenue dans la variable variable (ne vous laissez pas impressionner par l’apparente complexit´ de cette instruction !). Nous avons ´tendu, en algorithmique, l’instruction e e Afficher en intercalant des valeurs de variables entre les messages affich´s. Il est possible de faire de e mˆme en C : e p r i n t f ( ” l a v a l e u r de l a v a r i a b l e v e s t %d” , v ) ; Cette instruction substitue ` %d la valeur de la variable v. Il est possible de l’´tendre ` volont´ : a e a e p r i n t f ( ” l e s v a l e u r s d e s v a r i a b l e s x , y e t z s o n t %d , %d e t %d” , x , y , z ) ; Cette instruction substitue ` chaque %d les valeurs des trois variables x, y et z. Par exemple, le programme a suivant #include<s t d i o . h> int main ( ) { int a , b , c ; a = 1; b = 2; c = 3 p r i n t f ( ”La v a l e u r de a e s t %d , c e l l e de b e s t %d , e t c e l l e de ” ” c e s t %d . ” , a , b , c ) ; return 0 ; } affiche La valeur de a est 1, celle de b est 2, et celle de c est 3. 1.2.5 Entiers Trois types de base servent ` repr´senter les entiers : a e nom taille (t) nombre de valeurs (28t ) chaˆ de format ıne short 1 octet 28 valeurs %hd int 2 octets 216 valeurs %d long 4 octets 232 valeurs %ld 10
  • 12. Entiers non sign´s e Par d´faut, les entiers permettent de stocker des valeurs de signe quelconque. Si on pr´fixe un type entier e e par unsigned, on le restreint ` des valeurs uniquement positives. Dans ce cas, on a a nom taille (t) nombre de valeurs (28t ) valeur min valeur max format unsigned short 1 octet 28 valeurs 0 28 − 1 %hu 16 unsigned int 2 octets 2 valeurs 0 216 − 1 %u unsigned long 4 octets 232 valeurs 0 232 − 1 %lu La plage de valeur d’un unsigned short, encod´e en binaire, est e {0000 0000, 0000 0001, 0000 0010, 0000 0011, . . . , 1111 1110, 1111 1111} Entiers sign´s e Si par contre les donn´es sont sign´es, on a comme plage de valeurs e e nom taille (t) nombre de valeurs (28t ) plus petite valeur plus grande valeur short 1 octet 28 valeurs −27 27 − 1 16 int 2 octets 2 valeurs −215 215 − 1 32 long 4 octets 2 valeurs −231 231 − 1 La plage de valeur d’un short, encod´e en binaire, est aussi e {0000 0000, 0000 0001, 0000 0010, 0000 0011, . . . , 1111 1110, 1111 1111} Mˆme si les codages sont les mˆmes, la signification ne l’est pas, les nombres entiers positifs sont cod´s e e e sur l’intervalle : {0000 0000, 0000 0001, 0000 0010, 0000 0011, . . . , 0111 1100, 0111 1101, 0111 1110, 0111 1111} Et les nombres n´gatifs sur l’intervalle e {1000 0000, 1000 0001, 1000 0010, 1000 0011, . . . , 1111 1100, 1111 1101, 1111 1110, 1111 1111} Les nombres n´gatifs sont dispos´s du plus grand jusqu’au plus petit, l’intervalle pr´c´dent code les e e e e valeurs : {−27 , −(27 − 1), −(27 − 2), −(27 − 3), . . . , −4, −3, −2, −1} Les op´rations arithm´tiques sont ex´cut´es assez bˆtement, si vous calculez 0111 1111 + 0000 0001, ce e e e e e qui correspond ` (27 − 1) + 1, le r´sultat math´matique est 27 , ce qui se code 1000 0000, ce qui est le a e e codage de −27 . Soyez donc attentifs, en cas de d´passement de capacit´ d’un nombre entier, vous vous e e retrouverez avec des nombres qui ne veulent rien dire. Si vous souhaitez faire des calculs sur des r´els, un e type flottant sera davantage adapt´.e 1.2.6 Flottants Les flottants servent ` repr´senter les r´els. Leur nom vient du fait qu’on les repr´sente de fa¸on scien- a e e e c tifique : un nombre d´cimal (` virgule) muni d’un exposant (un d´calage de la virgule). Trois types de e a e base servent ` repr´senter les flottants : a e nom taille chaˆ de format ıne float 4 octet %f double 8 octets %f long double 10 octets %Lf Il est conventionel d’´crire des litt´raux flottants avec un point, par exemple l’approximation ` 10−2 pr`s e e a e de π s’ecrit 3.14. Il est aussi possible d’utiliser la notation scientifique, par exemple le d´cimal 1 000 e s’´crit 1e3, ` savoir 1.103 .Nous nous limiterons ` la description du type float, les autres types ob´issent e a a e a ` des r`gles similaires. e 11
  • 13. Repr´sentation en m´moire d’un float e e Le codage d’un nombre de type float (32 bits) est d´coup´ en trois parties : e e partie taille le bit de signe 1 bit l’exposant 8 bits la mantisse 23 bits Le nombre est positif si le bit de signe est ` 0, n´gatif si le bit de signe est ` 1. La mantisse et l’exposant a e a m sont cod´s en binaire, la valeur absolue d’un flottant de mantisse m et d’exposant e est 23 .2e . Le plus e 2 (223 − 1) grand entier qu’il est possible de coder sur 23 octets est , le plus grand exposant est 27 , donc 223 (223 − 1) (27 ) (223 − 1) (27 ) le plus grand flottant est 23 .2 , donc le plus petit est − .2 . 2 223 1.2.7 Caract`res e Un char sert ` repr´senter le code ASCII d’un caract`re, il est donc cod´ sur 1 octet. Il est possible a e e e d’affecter ` une telle variable toute valeur du code ASCII entour´e de simples quotes. Par exemple, a e l’affectation suivante place dans a le code ASCII du caract`re ’B’. e char a ; a = ’B ’ ; De la mˆme fa¸on que l’on code des nombres entiers sur 1 octet avec un short, un char contient avant e c tout un nombre cod´ sur 1 octet. Pour afficher le caract`re corrspondant au code ASCII stock´ dans un e e e char, on utilise la chaˆ de format %c, et pour afficher le code ASCII lui-mˆme on utilise la chaˆ de ıne e ıne format %d. Si on souhaite manipuler des char comme des nombres, le type unsigned char permet de coder des valeurs positives sur 1 octet, alors que char code aussi bien des nombres positifs que n´gatifs. e Par cons´quent, les caract`res de code ASCII 255 et 128 correspondent aux unsigned char de valeurs e e 255 et 128 et aux char de valeurs −1 et −128. 1.2.8 Constantes Une constante est une valeur portant un nom, contrairement aux variables, elles ne sont pas modifiables. Les constantes en C sont non typ´es, on les d´finit dans l’entˆte de la source, juste en dessous des #include. e e e La syntaxe est #define <NOM CONSTANTE> <valeurConstante>, par exemple #define N 25 d´finit une e constante N qui a la valeur 25. Au d´but de la compilation, un programme appel´ pr´processeur e e e effectue un rechercher/remplacer et substitue ` toutes les occurences de <NOM CONSTANTE> la valeur a <valeurConstante>. Faites donc tr`s attention au fait que dans l’exemple pr´sent, le pr´processeur e e e va remplacer tous les N par des 25. Donc si une variable s’appelle N , le pr´processeur va le remplacer e par un 25 ! Si par exemple vous ´crivez e #include<s t d i o . h> #define N 25 int main ( ) { int N; N = 12; p r i n t f ( ”N = %d” , N ) ; return 0 ; } Le pr´processeur va le transformer en e #include<s t d i o . h> 12
  • 14. #define N 25 int main ( ) { int 2 5 ; 25 = 1 2 ; p r i n t f ( ”N = %d” , 2 5 ) ; return 0 ; } Vous remarquez que les seules exceptions sont les valeurs d´limit´es par des ". e e 13
  • 15. 1.3 Op´rateurs e 1.3.1 G´n´ralit´s e e e Op´randes et arit´ e e Lorsque vous effectuez une op´ration, par exemple 3 + 4, le + est un op´rateur, 3 et 4 sont des op´randes. e e e Si l’op´rateur s’applique ` 2 op´randes, on dit qu’il s’agit d’un op´rateur binaire, ou bien d’arit´ 2. Un e a e e e op´rateur d’arit´ 1, dit aussi unaire, s’applique ` un seul op´rande, par exemple -x, le x est l’op´rande e e a e e et le - unaire est l’op´rateur qui, appliqu´ ` x, nous donne l’oppos´ de celui-ci, c’est-`-dire le nombre e e a e a qu’il faut additionner ` x pour obtenir 0. Il ne faut pas le confondre avec le - binaire, qui appliqu´ ` x et a ea y, additionne ` x l’oppos´ de y. a e En C, les op´rateurs sont unaires ou binaires, et il existe un seul op´rateur ternaire. e e Associativit´ e Si vous ´crivez une expression de la forme a + b + c, o` a, b et c sont des variables enti`res, vous e u e appliquez deux fois l’op´rateur binaire + pour calculer la somme de 3 nombres a, b et c. Dans quel ordre e ces op´rations sont-elles effectu´es ? Est-ce que l’on a (a + b) + c ou a + (b + c) ? Cela importe peu, e e car le + entier est associatif, ce qui signifie qu’il est possible de modifier le parenth`sage d’une somme e d’entiers sans en changer le r´sultat. Attention : l’associativit´ est une raret´ ! Peu d’op´rateurs sont e e e e associatifs, une bonne connaissance des r`gles sur les priorit´s et le parenth`sage par d´faut est donc e e e e requise. Formes pr´fixes, postfixes, infixes e Un op´rateur unaire est pr´fixe s’il se place avant son op´rande, postfixe s’il se place apr`s. Un op´rateur e e e e e binaire est infixe s’il se place entre ses deux op´randes (a + b), pr´fixe s’il se place avant (+ a b), e e postfixe s’il se place apr`s (a b +). Vous rencontrez en C des op´rateurs unaires pr´fixes et d’autres e e e postfixes (on imagine difficilement un op´rateur unaire infixe), par contre tous les op´rateurs binaires e e seront infixe. Priorit´s e Les r`gles des priorit´s en C sont nombreuses et complexes, nous ne ferons ici que les esquisser. Nous e e appelerons parenth`sage implicite le parenth`sage adopt´ par d´faut par le C, c’est ` dire l’ordre e e e e a dans lequel il effectue les op´rations. La premi`re r`gle ` retenir est qu’un op´rateur unaire est toujours e e e a e prioritaire sur un op´rateur binaire. e 1.3.2 Les op´rateurs unaires e N´gation arithm´tique e e La n´gation arithm´tique est l’op´rateur - qui ` une op´rande x, associe l’oppos´ de x, c’est-`-dire le e e e a e e a nombre qu’il faut additionner ` x pour obtenir 0. a N´gation binaire e La n´gation binaire ~ agit directement sur les bits de son op´rande, tous les bits ` 0 deviennent 1, et e e a vice-versa. Par exemple, ~127 (tous les bits ` 1 sauf le premier) est ´gal ` 128 (le premier bit ` 1 et tous a e a a les autres ` 0). a Priorit´s e Tous les op´rateurs unaires sont de priorit´ ´quivalente, le parenth`sage implicite est fait le plus ` droite e ee e a possible, on dit que ces op´rateurs sont associatifs ` droite. Par exemple, le parenth`sage implicite de e a e l’expression ~-~i est ~(-(~i)). C’est plutˆt logique : si vous parvenez ` placer les parenth`ses diff´rement, o a e e prevenez-moi parce que je ne vois pas comment faire... 14
  • 16. 1.3.3 Les op´rateurs binaires e Op´rations de d´calages de bits e e L’op´ration a >> 1 effectue un d´calage des bits de la repr´sentation binaire de a vers la droite. Tous les e e e bits sont d´cal´s d’un cran vers la droite, le dernier bit disparaˆ le premier prend la valeur 0. L’op´ration e e ıt, e a << 1 effectue un d´calage des bits de la repr´sentation binaire de a vers la gauche. Tous les bits sont e e d´cal´s d’un cran vers la gauche, le premier bit disparaˆ et le dernier devient 0. Par exemple, 32 << 2 e e ıt associe ` 0010 0000 << 2 la valeur dont la repr´sentation binaire 1000 0000 et 32 >> 3 associe ` 0010 a e a 0000 >> 3 la valeur dont la repr´sentation binaire 0000 0100. e Op´rations logiques sur la repr´sentation binaire e e L’op´rateur & associe ` deux op´randes le ET logique de leurs repr´sentations binaires par exemple e a e e 60 & 15 donne 12, autrement formul´ 0011 1100 ET 0000 1111 = 0000 1100. L’op´rateur | associe ` e e a deux op´randes le OU logique de leurs repr´sentations binaires par exemple 60 | 15 donne 63, autrement e e formul´ 0011 1100 OU 0000 1111 = 0011 1111. L’op´rateur ^ associe ` deux op´randes le OU exclusif e e a e logique de leurs repr´sentations binaires par exemple 60 ^ 15 donne 51, autrement formul´ 0011 1100 e e OU EXCLUSIF 0000 1111 = 0011 0011. Deux ^ successifs s’annulent, en d’autres termes a^b^b=a. Affectation Ne vous en d´plaise, le = est bien un op´rateur binaire. Celui-ci affecte ` l’op´rande de gauche (appel´e e e a e e Lvalue par le compilateur), qui doit ˆtre une variable, une valeur calcul´e ` l’aide d’une expression, qui e e a est l’op´rande de droite. Attention, il est possible d’effectuer une affectation pendant l’´valuation d’une e e expression. Par exemple, a = b + (c = 3); Cette expression affecte ` c la valeur 3, puis affecte ` a la valeur b + c. a a Priorit´s e Tous les op´rateurs binaires ne sont pas de priorit´s ´quivalentes. Ceux de priorit´ la plus forte sont les e e e e op´rateurs arithm´tiques (*, /, %, +, -), puis les op´rateus de d´calage de bit (<<, >>), les op´rateurs de bit e e e e e (&, ^, |), et enfin l’affectation =. Repr´sentons dans une tableau les op´rateurs en fonction de leur priorit´, e e e pla¸ons les plus prioritaire en haut et les moins prioritaires en bas. Parmi les op´rateurs arithm´tiques, c e e les multiplications et divisions sont prioritaires sur les sommes et diff´rence : e noms op´rateurs e produit *, /, % sommes +, - Les deux op´rateurs de d´calage sont de priorit´ ´quivalente : e e ee noms op´rateurs e d´calage binaire >>, << e L’op´rateur & est assimil´ ` un produit, | ` une somme. Donc , & est prioritaire sur |. Comme ^ se trouve e ea a entre les deux, on a noms op´rateurs e ET binaire & OU Exlusif binaire ^ OU binaire | Il ne nous reste plus qu’` assembler les tableaux : a 15
  • 17. noms op´rateurs e produit *, /, % somme +, - d´calage binaire e >>, << ET binaire & OU Exlusif binaire ^ OU binaire | affectation = Quand deux op´rateurs sont de mˆme priorit´ le parenth`sage implicite est fait le plus ` gauche pos- e e e e a sible, on dit que ces op´rateurs sont associatifs ` gauche. Par exemple, le parenth`sage implicite de e a e l’expression a - b - c est (a − b) − c et certainement pas a - (b - c). Ayez donc cela en tˆte lorsque vous manipulez des op´rateurs non e e associatifs ! La seule exception est le =, qui est associatif ` droite. Par exemple, a a = b = c; se d´compose en b = c suivi de a = b. e 1.3.4 Formes contract´es e Le C ´tant un langage de paresseux, tout ` ´t´ fait pour que les programmeurs aient le moins de caract`res e ae e e possible ` saisir. Je vous pr´viens : j’ai plac´ ce chapitre pour que soyez capable de d´crypter la bouillie a e e e que pondent certains programmeurs, pas pour que vous les imitiez ! Alors vous allez me faire le plaisir de faire usage des formes contract´es avec parcimonie, n’oubliez pas qu’il est tr`s important que votre code e e soit lisible. Unaires Il est possible d’incr´menter (augmenter de 1) la valeur d’une variable i en ´crivant i++, ou bien ++i. e e De la mˆme fa¸on on peut d´cr´menter (diminuer de 1) i en ´crivant i-- (forme postfixe), ou bien --i e c e e e (forme pr´fixe). Vous pouvez d´cider d’incr´menter (ou de d´cr´menter) la valeur d’une variable pendant e e e e e un calcul, par exemple, a = 1; b = ( a++) + a ; ´value successivement les deux op´randes a++ et a, puis affecte leur somme ` b. L’op´rande a++ est e e a e ´valu´e ` 1, puis est incr´ment´e, donc lorsque la deuxi`me op´rande a est ´valu´e, sa valeur est 2. Donc e e a e e e e e e la valeur de b apr`s l’incr´mentation est 3. L’incr´mentation contract´e sous forme postfixe s’appelle une e e e e post-incr´mentation. Si l’on ´crit, e e a = 1; b = (++a ) + a ; On op`re une pr´-incr´mentation, ++a donne lieu ` une incr´mentation avant l’´valuation de a, donc e e e a e e la valeur 4 est affect´e ` b. On peut de fa¸on analogue effectuer une pr´-decr´mentation ou a post- e a c e e decr´mentation. Soyez tr`s attentifs au fait que ce code n’est pas portable, il existe des compilateurs e e qui ´valuent les op´randes dans le d´sordre ou diff`rent les incr´mentations, donnant ainsi des r´sultats e e e e e e autres que les r´sultats th´oriques expos´s pr´c´dement. Vous n’utiliserez donc les incr´mentation et e e e e e e decr´mentation contract´es que lorsque vous serez certain que l’ordre d’´valuation des op´randes ne e e e e pourra pas influer sur le r´sultat. e Binaires Toutes les affectations de la forme variable = variable operateurBinaire expression peuvent ˆtre e contract´es sous la forme variable operateurBinaire= expression. Par exemple, e 16
  • 18. avant apr`s e a = a + b a += b a = a - b a -= b a = a * b a *= b a = a / b a /= b a = a % b a %= b a = a & b a &= b a = a ^ b a ^= b a = a | b a |= b Vous vous douterez que l’´galit´ ne peut pas ˆtre contract´e... e e e e 1.3.5 Op´rations h´t´rog`nes e e e e Le fonctionnement par d´faut e Nous ordonnons de fa¸on grossi`re les types de la fa¸on suivante : long double > double > float > c e c unsigned long > long > unsigned int > int > unsigned short > short > char. Dans un cal- cul o` les op´randes sont de types h´t´rog`nes, l’op´rande dont le type T est de niveau le plus ´l´v´ u e ee e e ee e (conform´ment ` l’ordre ´nonc´ ci-avant) est s´lectionn´ et l’autre est converti dans le type T . e a e e e e Le probl`me e Il se peut cependant que dans un calcul, cela ne convienne pas. Si par exemple, vous souhaitez calculer 1 l’inverse d’un nombre entier x, et que vous codez x int i = 4 ; p r i n t f ( ”L ’ i n v e r s e de %d e s t %d” , i , 1/ i ) ; Vous constaterez que r´sultat est inint´ressant au possible. En effet, comme i et 1 sont tout deux de type e e entier, c’est la division enti`re est effectu´e, et de toute ´vidence le r´sultat est 0. Changer la chaˆ de e e e e ıne format int i = 4 ; p r i n t f ( ”L ’ i n v e r s e de %d e s t %f n” , i , 1/ i ) ; se r´v`lera aussi d’une inefficacit´ notoire : non seulement vous vous taperez un warning, mais en plus e e e printf lira un entier en croyant que c’est un flottant. Alors comment on se sort de l` ? Ici la bidouille a est simple, il suffit d’´crire le 1 avec un point : e int i = 4 ; p r i n t f ( ”L ’ i n v e r s e de %d e s t %f n” , i , 1 . / i ) ; Le compilateur, voyant un op´rande de type flottant, convertit lors du calcul l’autre op´rande, i, en e e flottant. De ce fait, c’est une division flottante et non enti`re qui est effectu´e. Allons plus loin : comment e e faire pour appliquer une division flottante ` deux entiers ? Par exemple : a int i = 4 , j= 5 ; p r i n t f ( ”Le q u o t i e n t de %d e t %d e s t %f n” , i , j , i / j ) ; Cette fois-ci c’est inextricable, vous pouvez placer des points o` vous voudrez, vous n’arriverez pas ` u a vous d´barasser du warning et ce programme persistera ` vous dire que ce quotient est -0.000000 ! Une e a solution particuli`rement crade serait de recopier i et j dans des variables flottantes avant de faire la e division, une autre m´thode de bourrin est de calculer (i + 0.)/j. Mais j’esp`re que vous r´alisez que e e e seuls les boeufs proc`dent de la sorte. e Le cast Le seul moyen de vous sortir de l` est d’effectuer un cast, c’est ` dire une conversion de type sur com- a a mande. On caste en pla¸ant entre parenth`se le type dans lequel on veut convertir juste avant l’op´rande c e e que l’on veut convertir. Par exemple, 17
  • 19. int i = 4 , j= 5 ; p r i n t f ( ”Le q u o t i e n t de %d e t %d e s t %f n” , i , j , ( f l o a t ) i / j ) ; Et l`, ¸a fonctionne. La variable valeur contenue dans i est convertie en float et de ce fait, l’autre a c op´rande, j, est aussi convertie en float. La division est donc une division flottante. Notez bien que le e cast est un op´rateur unaire, donc prioritaire sur la division qui est un op´rateur binaire, c’est pour ¸a e e c que la conversion de i a lieu avant la division. Mais si jamais il vous vient l’id´e saugrenue d’´crire e e int i = 4 , j= 5 ; p r i n t f ( ”Le q u o t i e n t de %d e t %d e s t %f n” , i , j , ( f l o a t ) ( i / j ) ) ; Vous constaterez tr`s rapidement que c’est une alternative peu intelligente. En effet, le r´sulat est flottant, e e mais comme la division a lieu avant toute conversion, c’est le r´sultat d’une division enti`re qui est converti e e en flottant, vous avez donc le mˆme r´sultat que si vous n’aviez pas du tout cast´. e e e 1.3.6 Les priorit´s e Ajoutons le cast au tableau des priorit´s de nos op´rateurs : e e noms op´rateurs e op´rateurs unaires cast, -, ~, ++, -- e produit *, /, % somme +, - d´calage binaire e >>, << ET binaire & OU Exlusif binaire ^ OU binaire | affectation = 18
  • 20. 1.4 Traitements conditionnels On appelle traitement conditionnel un portion de code qui n’est pas ex´cut´e syst´matiquement, c’est ` e e e a dire des instructions dont l’ex´cution est conditionn´e par le succ`s d’un test. e e e 1.4.1 Si ... Alors Principe En algorithmique un traitement conditionnel se r´dige de la sorte : e si condition alors instructions fin Si la condition est v´rifi´e, alors les instructions sont ex´cut´es, sinon, elles ne sont pas ex´cut´es. e e e e e e L’ex´cution de l’algorithme se poursuit alors en ignorant les instructions se trouvant entre le alors e et le finSi. Un traitement conditionnel se code de la sorte : i f (< c o n d i t i o n >) { <i n s t r u c t i o n s > } Notez bien qu’il n’y a pas de point-virgule apr`s la parenth`se du if. e e Comparaisons La formulation d’une condition se fait souvent ` l’aide des op´rateurs de comparaison. Les op´rateurs de a e e comparaison disponibles sont : – == : ´galit´ e e – != : non-´galit´ e e – <, <= : inf´rieur `, respectivement strict et large e a – >, >= : sup´rieur `, respectivement strict et large e a Par exemple, la condition a == b est v´rifi´e si et seulement si a et b ont la mˆme valeur au moment o` e e e u le test est ´valu´. Par exemple, e e #include<s t d i o . h> int main ( ) { int i ; p r i n t f ( ” S a i s i s s e z une v a l e u r : ” ) ; s c a n f ( ”%d” , &i ) ; i f ( i == 0 ) { p r i n t f ( ”Vous avez s a i s i une v a l e u r n u l l e n . ” ) ; } p r i n t f ( ” Adios ! ” ) ; return 0 ; } Si au moment o` le test i == 0 est ´valu´, la valeur de i est bien 0, alors le test sera v´rifi´ et l’instruction u e e e e printf("Vous avez saisi une valeur nullen.") sera bien ex´cut´e. Si le test n’est pas v´rifi´, les e e e e instructions du bloc ... suivant le if sont ignor´es. e 19
  • 21. Si ... Alors ... Sinon Il existe une forme ´tendue de traitement conditionnel, on la note en algorithmique de la fa¸on suivante : e c si condition alors instructions sinon autresinstructions fin Les instructions d´limit´es par alors et sinon sont ex´cut´es si le test est v´rifi´, et les instructions e e e e e e d´limit´es par sinon et finSi sont ex´cut´es si le test n’est pas v´rifi´. On traduit le traitement condi- e e e e e e tionnel ´tendu de la sorte : e i f (< c o n d i t i o n >) { <i n s t r u c t i o n s 1 > } else { <i n s t r u c t i o n s 2 > } Par exemple, #include<s t d i o . h> int main ( ) { int i ; p r i n t f ( ” S a i s i s s e z une v a l e u r : ” ) ; s c a n f ( ”%d” , &i ) ; i f ( i == 0 ) { p r i n t f ( ”Vous avez s a i s i une v a l e u r n u l l e n . ” ) ; } else { p r i n t f ( ”La v a l e u r que vous s a i s i , ” ” a s a v o i r %d , n ’ e s t pas n u l l e . n” , i ) ; } return 0 ; } Notez la pr´sence de l’op´rateur de comparaison ==. N’utilisez jamais = pour comparer deux va- e e leurs !. Connecteurs logiques On formule des conditions davantage ´labor´es en utilisant des connecteurs et et ou. La condition A et e e B est v´rifi´e si les deux conditions A et B sont v´rifi´es simultan´ment. La condition A ou B est v´rifi´e e e e e e e e si au moins une des deux conditions A et B est v´rifi´e. Le et s’´crit && et le ou s’´crit ||. Par exemple, e e e e voici un programme C qui nous donne le signe de i × j sans les multiplier. #include<s t d i o . h> int main ( ) { int i , j ; 20
  • 22. p r i n t f ( ” S a i s i s s e z deux v a l e u r s : ” ) ; s c a n f ( ”%d %d” , &i , &j ) ; p r i n t f ( ”Le p r o d u i t de c e s deux v a l e u r s e s t ” ) ; i f ( ( i < 0 && j < 0 ) | | ( i >= 0 && j>= 0 ) ) { p r i n t f ( ” p o s i t i f n . ” ) ; } else { printf (” n´gatif ” ) ; e } p r i n t f ( ” . n” ) ; return 0 ; } Accolades superflues Lorsqu’une seule instruction d’un bloc if doit ˆtre ex´cut´e, les accolades ne sont plus n´cessaires. Il est e e e e possible par exemple de reformuler le programme pr´c´dent de la sorte : e e #include<s t d i o . h> int main ( ) { int i , j ; p r i n t f ( ” S a i s i s s e z deux v a l e u r s : ” ) ; s c a n f ( ”%d %d” , &i , &j ) ; p r i n t f ( ”Le p r o d u i t de c e s deux v a l e u r s e s t ” ) ; i f ( ( i < 0 && j < 0 ) | | ( i >= 0 && j>= 0 ) ) p r i n t f ( ” p o s i t i f n . ” ) ; else printf (” n´gatif ” ) ; e p r i n t f ( ” . n” ) ; return 0 ; } Op´rateur ternaire e En pla¸ant l’instruction suivante ` droite d’une affectation, c a <v a r i a b l e > = (< c o n d i t i o n >) ? <v a l e u r > : <a u t r e v a l e u r > ; on place valeur dans variable si condition est v´rifi´, autrevaleur sinon. Par exemple, e e max = ( i >j ) ? i : j ; place la plus grande des deux valeurs i et j dans max. Plus g´n´ralement on peut utiliser le si ternaire e e dans n’importe quel calcul, par exemple p r i n t f ( ”%dn” , ( i > ( l = ( j >k ) ? j : k ) ) ? i : l ) ; j = (j>k) ? j : k) place dans l la plus grande des valeurs j et k, donc (i > (l = (j > k) ? j : k)) ? i : l est la plus grande des valeurs i, j et k. La plus grande de ces trois valeurs est donc affich´e e par cette instruction. 1.4.2 Switch Le switch en C s’´crit, avec la syntaxe suivante : e 21
  • 23. switch(< nomvariable >) { case <v a l e u r 1 > : <i n s t r u c t i o n s 1 > ; break ; case <v a l e u r 2 > : <i n s t r u c t i o n s 2 > ; break ; /∗ . . . ∗/ case <v a l e u r n > : <i n s t r u c t i o n s n > ; break ; default : /∗ i n s t r u c t i o n s ∗/ } N’oubliez surtout pas les break ! Si par exemple, nous voulons afficher le nom d’un mois en fonction de son num´ro, on ´crit e e switch ( numeroMois ) { case 1 : p r i n t f ( ” j a n v i e r ” ) ; break ; case 2 : p r i n t f ( ” f e v r i e r ” ) ; break ; case 3 : p r i n t f ( ” mars ” ) ; break ; case 4 : p r i n t f ( ” a v r i l ” ) ; break ; case 5 : p r i n t f ( ”mai” ) ; break ; case 6 : p r i n t f ( ” j u i n ” ) ; break ; case 7 : p r i n t f ( ” j u i l l e t ” ) ; break ; case 8 : p r i n t f ( ” aout ” ) ; break ; case 9 : p r i n t f ( ” septembre ” ) ; break ; case 10 : p r i n t f ( ” o c t o b r e ” ) ; break ; case 11 : p r i n t f ( ” novembre ” ) ; break ; case 12 : p r i n t f ( ” decembre ” ) ; break ; default : p r i n t f ( ” Je c o n n a i s pas c e mois . . . ” ) ; } 1.4.3 Bool´ens e Une variable bool´enne ne peut prendre que deux valeurs : vrai et f aux. Il n’existe pas de type bool´en e e a ` proprement parler en C. On utilise des int pour simuler le comportement des bool´ens. On repr´sente e e la valeur bool´enne f aux avec la valeur enti`re 0, toutes les autres valeurs enti`res servent ` repr´senter e e e a e vrai. Utilisation dans des if Lorsqu’une condition est ´valu´e, par exemple lors d’un test, cette condition prend ` ce moment la valeur e e a vrai si le test est v´rifi´, f aux dans le cas contraire. La valeur enti`re 0 repr´sente la constante f aux et e e e e toutes les autres sont des constantes vrai. Observons le test suivant : i f (8) { // . . . 1 est un litt´ral de type entier dont le valeur est non nulle, donc il repr´sente le bool´en vrai. De ce fait, e e e le test if (8) est toujours v´rifi´. Par contre le test if (0) n’est jamais v´rifi´. e e e e La valeur vrai Mˆme si tout entier non nul a la valeur vrai, on prend par d´faut la valeur 1. Lorsqu’une condition est e e ´valu´e, elle prend la valeur 1 si elle est v´rifi´, 0 dans le cas contraire. par exemple, e e e e x = (3 >2); On remarque que (3>2) est une condition. Pour d´cider quelle valeur doit ˆtre affect´e ` x, cette condition e e e a est ´valu´e. Comme dans l’exemple ci-dessus la condition est v´rifi´e, alors elle prend la valeur 1, et cette e e e e valeur est affect´e ` x. e a 22
  • 24. Connecteurs logiques binaires Les connecteurs || et && peuvent s’appliquer ` des valeurs (ou variables) enti`res. Observons l’exemple a e suivant : x = ( 3 && 0 ) | | ( 1 ) ; Il s’agit de l’affectation ` x de l’´valuation de la condition (3 && 0) || (1). Comme 3 est vrai et 0 est a e faux, alors leur conjonction est fausse. Donc (3 && 0) a pour valeur 0. La condition 0 || 1 est ensuite ´valu´e et prend la valeur vrai. Donc la valeur 1 est affect´e ` x. e e e a Op´rateur de n´gation e e Parmi les connecteurs logiques se trouve !, dit op´rateur de n´gation. La n´gation d’une expression est e e e vraie si l’expression est fausse, fausse si l’expression est vraie. Par exemple, x = !(3==2); Comme 3 == 2 est faux, alors sa n´gation !(3 == 2) est vraie. Donc la valeur 1 est affect´e ` x. e e a 1.4.4 Les priorit´s e Compl`tons notre tableau e des priorit´s en y adjoignant les connecteurs logiques et les op´rateurs de e e comparaison : noms op´rateurs e op´rateurs unaires e cast, -, ~, !, ++, -- produit *, /, % somme +, - d´calage binaire e >>, << comparaison >, <, >=, <= ´galit´ e e ==, != ET binaire & OU Exlusif binaire ^ OU binaire | connecteurs logiques &&, || if ternaire () ? : affectations =, +=, -=, . . . 1.4.5 Pr´processeur e Macro-instructions Le C nous permet de placer ` peu pr`s n’importe quoi dans les constantes. Si par exemple, on est lass´ a e e d’´crire des instructions de retour ` la ligne, il suffit de d´finir e a e #define RC p r i n t f ( ”n” ) Dans ce cas, toutes les occurrences de RC dans le code seront remplac´es par des printf("n"). Par e exemple #include<s t d i o . h> #define BEGIN { #define END } #define RC p r i n t f ( ”n” ) #define AFFICHE DEBUT p r i n t f ( ”Debut” ) #define AFFICHE FIN p r i n t f ( ” Fin ” ) #define AFFICHE MLILIEU p r i n t f ( ” M i l i e u ” ) 23