Initiation au Langage C      Alexandre Mesl´                    e       16 juin 2009
Table des mati`res              e1 Notes de cours                                                                         ...
1.7.3 D´claration . . . . . . . . . . . . . .                 e                                            .   .   .   .  ...
2.3  Boucles . . . . . . . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   ...
A Quelques corrig´s e                                                                                                     ...
B Projets                                                                                              194  B.1 Agenda (po...
Chapitre 1Notes de cours1.1     Introduction1.1.1    D´finitions et terminologie          eUn programme ex´cutable est une ...
(ex. : Notepad), ce type de fichier s’appelle une source. Les instructions qui y sont ´crites s’appellent                  ...
<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-vir...
1.2        VariablesUne variable est un emplacement de la m´moire dans lequel est stock´e une valeur. Chaque variable port...
z = v + w / 2;            v = z % 3;            v = v ∗ 2;            return 0 ;}1.2.3      SaisieTraduisons en C l’instru...
Entiers non sign´s                ePar d´faut, les entiers permettent de stocker des valeurs de signe quelconque. Si on pr...
Repr´sentation en m´moire d’un float    e              eLe codage d’un nombre de type float (32 bits) est d´coup´ en trois...
#define N 25int main ( ){  int 2 5 ;  25 = 1 2 ;  p r i n t f ( ”N = %d” , 2 5 ) ;  return 0 ;}Vous remarquez que les seul...
1.3     Op´rateurs          e1.3.1    G´n´ralit´s          e e     eOp´randes et arit´  e              eLorsque vous effect...
1.3.3     Les op´rateurs binaires                eOp´rations de d´calages de bits  e            eL’op´ration a >> 1 effectu...
noms                 op´rateurs                             e     produit              *, /, %     somme                +,...
avant        apr`s                    e    a = a + b a +=         b    a = a - b a -=         b    a = a * b 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 , ( f l o a t ) i / j ) ;Et l`, ¸a fo...
1.4       Traitements conditionnelsOn appelle traitement conditionnel un portion de code qui n’est pas ex´cut´e syst´matiq...
Si ... Alors ... SinonIl existe une forme ´tendue de traitement conditionnel, on la note en algorithmique de la fa¸on suiv...
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...
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...
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
Langage c
Prochain SlideShare
Chargement dans…5
×

Langage c

633 vues

Publié le

0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
633
Sur SlideShare
0
Issues des intégrations
0
Intégrations
4
Actions
Partages
0
Téléchargements
51
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Langage c

  1. 1. Initiation au Langage C Alexandre Mesl´ e 16 juin 2009
  2. 2. Table des mati`res e1 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. 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´ . . . . . . . . . . . . . . . . . . . . . . . . . . 742 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. 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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 862.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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 892.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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 922.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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 992.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 . . . . . . . . . . . . . . . . . . . . . . . . . 1032.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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1092.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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1122.10 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1172.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. 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. 6. B Projets 194 B.1 Agenda (pour les PPAs) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194A 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. 7. Chapitre 1Notes de cours1.1 Introduction1.1.1 D´finitions et terminologie eUn programme ex´cutable est une suite d’instructions ex´cut´e par le processeur. Ces instructions sont e e etr`s difficile ` comprendre, si par exemple, vous ouvrez avec un ´diteur de texte (notepad, emacs, etc) un e a efichier ex´cutable, vous verrez s’afficher un charabia incompr´hensible : e e000000000000001f0000003e0000005d0000007c0000009b000000ba000000d9000000f80000011700000136000001550000017400000193000001b2000001d1000001f00000020f0000022e0000024d0000026c0000028b000002aa000002c9000002e800000307...Il n’est pas envisageable de cr´er des programmes en ´crivant des suites de chiffres et de lettres. Nous e eallons 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. 8. (ex. : Notepad), ce type de fichier s’appelle une source. Les instructions qui y sont ´crites s’appellent edu code ou encore le code source. Un compilateur est un logiciel qui lit le code source et le convertiten un code ex´cutable, c’est-`-dire un ensemble d’instructions compr´hensible par le processeur. La e a ecompilation d’une source se fait en deux ´tapes : la compilation proprement dite et le linkage. On utilise een 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 eCertains environnement de d´veloppement servent d’´diteur, et prennent en charge la compilation et le e elinkage (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- eedessous 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- equez 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 e1.1.3 Structure d’un programme CImportation 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. eCelles-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 eCorps du programmeint 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 : eint main ( ){ 7
  9. 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 eC s’´crivent entre doubles quotes. getch() ; nous sert ` suspendre l’ex´cution du programme jusqu’` ce e a e aque l’utilisateur appuie sur une touche.1.1.4 CommentairesUn commentaire est une s´quence de caract`res ignor´e par le compilateur, on s’en sert pour expliquer e e edes portions de code. Alors ayez une pens´e pour les pauvres programmeurs qui vont reprendre votre ecode apr`s vous, le pauvre correcteur qui va essayer de comprendre votre pens´e profonde, ou bien plus e esimplement ` vous-mˆme au bout de six mois, quand vous aurez compl`tement oubli´ ce que vous aviez a e e edans la tˆte en codant. On d´limite un commentaire par /* et */. Par exemple, e eint 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. 10. 1.2 VariablesUne variable est un emplacement de la m´moire dans lequel est stock´e une valeur. Chaque variable porte e eune nom et c’est ce nom qui sert ` identifi´ l’emplacement de la m´moire repr´sent´ par cette variable. a e e e ePour utiliser une variable, la premi`re ´tape est la d´claration. e e e1.2.1 D´claration eD´clarer une variable, c’est pr´venir le compilateur qu’un nom va ˆtre utilis´ pour d´signer un emplace- e e e e ement de la m´moire. En C, on d´clare les variables juste apr`s l’accolade suivant main() (pour le moment). e e eOn place les instructions ` ex´cuter ` la suite de la d´claration de variables. a e a emain ( ){ <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 ecorrespond, en C, est int. On d´clare les variables enti`res de la mani`re suivante : e e eint <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 AffectationSi on souhaite affecter ` la variable v une valeur, on utilise l’op´rateur =. Par exemple, a eint 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 evous venez de le voir, il est possible d’´crire directement dans le code une valeur que l’on donne ` une e avariable. Notez l’abscence de include, ce programme n’effectue aucune entr´e-sortie, il n’est donc pas en´cessaire d’importer les biblioth`ques d’entr´es/sorties. e e eLes op´rations arihm´tiques disponibles sont l’addition (+), la soustraction (-), la multiplication (*), e ela division enti`re dans l’ensemble des entiers relatifs (quotient : /, reste : %). eint main ( ){ int v , w, z ; v = 5; w = v + 1; 9
  11. 11. z = v + w / 2; v = z % 3; v = v ∗ 2; return 0 ;}1.2.3 SaisieTraduisons en C l’instruction Saisir <variable> que nous avons vu en algorithmique. Pour r´cup´rer e ela 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 etouche return. La valeur saisie est alors affet´e ` la variable <variable>. N’oubliez surtout pas le &, e asinon des choses absurdes pourraient se produire !1.2.4 AffichageTraduisons maintenant l’instruction Afficher variable en C. Cette instruction permet d’afficher lavaleur 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 impressionnerpar l’apparente complexit´ de cette instruction !). Nous avons ´tendu, en algorithmique, l’instruction e eAfficher en intercalant des valeurs de variables entre les messages affich´s. Il est possible de faire de emˆme en C : ep 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 ep 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 asuivant#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 ;}afficheLa valeur de a est 1, celle de b est 2, et celle de c est 3.1.2.5 EntiersTrois 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. 12. Entiers non sign´s ePar d´faut, les entiers permettent de stocker des valeurs de signe quelconque. Si on pr´fixe un type entier e epar 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 %luLa 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 eSi 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 − 1La 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 esur 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 evaleurs : {−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 equi correspond ` (27 − 1) + 1, le r´sultat math´matique est 27 , ce qui se code 1000 0000, ce qui est le a e ecodage de −27 . Soyez donc attentifs, en cas de d´passement de capacit´ d’un nombre entier, vous vous e eretrouverez avec des nombres qui ne veulent rien dire. Si vous souhaitez faire des calculs sur des r´els, un etype flottant sera davantage adapt´.e1.2.6 FlottantsLes 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 ctifique : un nombre d´cimal (` virgule) muni d’un exposant (un d´calage de la virgule). Trois types de e a ebase 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 %LfIl est conventionel d’´crire des litt´raux flottants avec un point, par exemple l’approximation ` 10−2 pr`s e e a ede π s’ecrit 3.14. Il est aussi possible d’utiliser la notation scientifique, par exemple le d´cimal 1 000 es’´crit 1e3, ` savoir 1.103 .Nous nous limiterons ` la description du type float, les autres types ob´issent e a a ea` des r`gles similaires. e 11
  13. 13. Repr´sentation en m´moire d’un float e eLe 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 bitsLe 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 msont 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 2231.2.7 Caract`res eUn char sert ` repr´senter le code ASCII d’un caract`re, il est donc cod´ sur 1 octet. Il est possible a e e ed’affecter ` une telle variable toute valeur du code ASCII entour´e de simples quotes. Par exemple, a el’affectation suivante place dans a le code ASCII du caract`re ’B’. echar 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 ctout un nombre cod´ sur 1 octet. Pour afficher le caract`re corrspondant au code ASCII stock´ dans un e e echar, on utilise la chaˆ de format %c, et pour afficher le code ASCII lui-mˆme on utilise la chaˆ de ıne e ıneformat %d. Si on souhaite manipuler des char comme des nombres, le type unsigned char permet decoder des valeurs positives sur 1 octet, alors que char code aussi bien des nombres positifs que n´gatifs. ePar cons´quent, les caract`res de code ASCII 255 et 128 correspondent aux unsigned char de valeurs e e255 et 128 et aux char de valeurs −1 et −128.1.2.8 ConstantesUne 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 eLa syntaxe est #define <NOM CONSTANTE> <valeurConstante>, par exemple #define N 25 d´finit une econstante N qui a la valeur 25. Au d´but de la compilation, un programme appel´ pr´processeur e e eeffectue 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 eva remplacer tous les N par des 25. Donc si une variable s’appelle N , le pr´processeur va le remplacer epar un 25 ! Si par exemple vous ´crivez e#include<s t d i o . h>#define N 25int 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. 14. #define N 25int 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. 15. 1.3 Op´rateurs e1.3.1 G´n´ralit´s e e eOp´randes et arit´ e eLorsque vous effectuez une op´ration, par exemple 3 + 4, le + est un op´rateur, 3 et 4 sont des op´randes. e e eSi 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 eop´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 eet 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 aqu’il faut additionner ` x pour obtenir 0. Il ne faut pas le confondre avec le - binaire, qui appliqu´ ` x et a eay, additionne ` x l’oppos´ de y. a eEn C, les op´rateurs sont unaires ou binaires, et il existe un seul op´rateur ternaire. e eAssociativit´ eSi vous ´crivez une expression de la forme a + b + c, o` a, b et c sont des variables enti`res, vous e u eappliquez deux fois l’op´rateur binaire + pour calculer la somme de 3 nombres a, b et c. Dans quel ordre eces op´rations sont-elles effectu´es ? Est-ce que l’on a (a + b) + c ou a + (b + c) ? Cela importe peu, e ecar le + entier est associatif, ce qui signifie qu’il est possible de modifier le parenth`sage d’une somme ed’entiers sans en changer le r´sultat. Attention : l’associativit´ est une raret´ ! Peu d’op´rateurs sont e e e eassociatifs, une bonne connaissance des r`gles sur les priorit´s et le parenth`sage par d´faut est donc e e e erequise.Formes pr´fixes, postfixes, infixes eUn 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 ebinaire est infixe s’il se place entre ses deux op´randes (a + b), pr´fixe s’il se place avant (+ a b), e epostfixe s’il se place apr`s (a b +). Vous rencontrez en C des op´rateurs unaires pr´fixes et d’autres e e epostfixes (on imagine difficilement un op´rateur unaire infixe), par contre tous les op´rateurs binaires e eseront infixe.Priorit´s eLes r`gles des priorit´s en C sont nombreuses et complexes, nous ne ferons ici que les esquisser. Nous e eappelerons parenth`sage implicite le parenth`sage adopt´ par d´faut par le C, c’est ` dire l’ordre e e e e adans lequel il effectue les op´rations. La premi`re r`gle ` retenir est qu’un op´rateur unaire est toujours e e e a eprioritaire sur un op´rateur binaire. e1.3.2 Les op´rateurs unaires eN´gation arithm´tique e eLa 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 anombre qu’il faut additionner ` x pour obtenir 0. aN´gation binaire eLa n´gation binaire ~ agit directement sur les bits de son op´rande, tous les bits ` 0 deviennent 1, et e e avice-versa. Par exemple, ~127 (tous les bits ` 1 sauf le premier) est ´gal ` 128 (le premier bit ` 1 et tous a e a ales autres ` 0). aPriorit´s eTous les op´rateurs unaires sont de priorit´ ´quivalente, le parenth`sage implicite est fait le plus ` droite e ee e apossible, on dit que ces op´rateurs sont associatifs ` droite. Par exemple, le parenth`sage implicite de e a el’expression ~-~i est ~(-(~i)). C’est plutˆt logique : si vous parvenez ` placer les parenth`ses diff´rement, o a e eprevenez-moi parce que je ne vois pas comment faire... 14
  16. 16. 1.3.3 Les op´rateurs binaires eOp´rations de d´calages de bits e eL’op´ration a >> 1 effectue un d´calage des bits de la repr´sentation binaire de a vers la droite. Tous les e e ebits 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, ea << 1 effectue un d´calage des bits de la repr´sentation binaire de a vers la gauche. Tous les bits sont e ed´cal´s d’un cran vers la gauche, le premier bit disparaˆ et le dernier devient 0. Par exemple, 32 << 2 e e ıtassocie ` 0010 0000 << 2 la valeur dont la repr´sentation binaire 1000 0000 et 32 >> 3 associe ` 0010 a e a0000 >> 3 la valeur dont la repr´sentation binaire 0000 0100. eOp´rations logiques sur la repr´sentation binaire e eL’op´rateur & associe ` deux op´randes le ET logique de leurs repr´sentations binaires par exemple e a e e60 & 15 donne 12, autrement formul´ 0011 1100 ET 0000 1111 = 0000 1100. L’op´rateur | associe ` e e adeux op´randes le OU logique de leurs repr´sentations binaires par exemple 60 | 15 donne 63, autrement e eformul´ 0011 1100 OU 0000 1111 = 0011 1111. L’op´rateur ^ associe ` deux op´randes le OU exclusif e e a elogique de leurs repr´sentations binaires par exemple 60 ^ 15 donne 51, autrement formul´ 0011 1100 e eOU EXCLUSIF 0000 1111 = 0011 0011. Deux ^ successifs s’annulent, en d’autres termes a^b^b=a.AffectationNe 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 eLvalue par le compilateur), qui doit ˆtre une variable, une valeur calcul´e ` l’aide d’une expression, qui e e aest l’op´rande de droite. Attention, il est possible d’effectuer une affectation pendant l’´valuation d’une e eexpression. Par exemple,a = b + (c = 3);Cette expression affecte ` c la valeur 3, puis affecte ` a la valeur b + c. a aPriorit´s eTous les op´rateurs binaires ne sont pas de priorit´s ´quivalentes. Ceux de priorit´ la plus forte sont les e e e eop´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 epla¸ons les plus prioritaire en haut et les moins prioritaires en bas. Parmi les op´rateurs arithm´tiques, c e eles 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 >>, << eL’op´rateur & est assimil´ ` un produit, | ` une somme. Donc , & est prioritaire sur |. Comme ^ se trouve e ea aentre 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. 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 asible, on dit que ces op´rateurs sont associatifs ` gauche. Par exemple, le parenth`sage implicite de e a el’expression a - b - c est(a − b) − cet certainement pas a - (b - c). Ayez donc cela en tˆte lorsque vous manipulez des op´rateurs non e eassociatifs ! La seule exception est le =, qui est associatif ` droite. Par exemple, aa = b = c;se d´compose en b = c suivi de a = b. e1.3.4 Formes contract´es eLe C ´tant un langage de paresseux, tout ` ´t´ fait pour que les programmeurs aient le moins de caract`res e ae e epossible ` saisir. Je vous pr´viens : j’ai plac´ ce chapitre pour que soyez capable de d´crypter la bouillie a e e eque pondent certains programmeurs, pas pour que vous les imitiez ! Alors vous allez me faire le plaisir defaire usage des formes contract´es avec parcimonie, n’oubliez pas qu’il est tr`s important que votre code e esoit lisible.UnairesIl est possible d’incr´menter (augmenter de 1) la valeur d’une variable i en ´crivant i++, ou bien ++i. e eDe 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 eun 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++ este 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. Donce e a e e e e e ela valeur de b apr`s l’incr´mentation est 3. L’incr´mentation contract´e sous forme postfixe s’appelle une e e e epost-incr´mentation. Si l’on ´crit, e ea = 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 ela valeur 4 est affect´e ` b. On peut de fa¸on analogue effectuer une pr´-decr´mentation ou a post- e a c e edecr´mentation. Soyez tr`s attentifs au fait que ce code n’est pas portable, il existe des compilateurs e equi ´valuent les op´randes dans le d´sordre ou diff`rent les incr´mentations, donnant ainsi des r´sultats e e e e e eautres que les r´sultats th´oriques expos´s pr´c´dement. Vous n’utiliserez donc les incr´mentation et e e e e e edecr´mentation contract´es que lorsque vous serez certain que l’ordre d’´valuation des op´randes ne e e e epourra pas influer sur le r´sultat. eBinairesToutes les affectations de la forme variable = variable operateurBinaire expression peuvent ˆtre econtract´es sous la forme variable operateurBinaire= expression. Par exemple, e 16
  18. 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 |= bVous vous douterez que l’´galit´ ne peut pas ˆtre contract´e... e e e e1.3.5 Op´rations h´t´rog`nes e e e eLe fonctionnement par d´faut eNous ordonnons de fa¸on grossi`re les types de la fa¸on suivante : long double > double > float > c e cunsigned 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 eLe probl`me eIl se peut cependant que dans un calcul, cela ne convienne pas. Si par exemple, vous souhaitez calculer 1l’inverse d’un nombre entier x, et que vous codez xint 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 eentier, 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 ıneformatint 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 eprintf lira un entier en croyant que c’est un flottant. Alors comment on se sort de l` ? Ici la bidouille aest simple, il suffit d’´crire le 1 avec un point : eint 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 eflottant. De ce fait, c’est une division flottante et non enti`re qui est effectu´e. Allons plus loin : comment e efaire pour appliquer une division flottante ` deux entiers ? Par exemple : aint 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 avous d´barasser du warning et ce programme persistera ` vous dire que ce quotient est -0.000000 ! Une e asolution particuli`rement crade serait de recopier i et j dans des variables flottantes avant de faire la edivision, une autre m´thode de bourrin est de calculer (i + 0.)/j. Mais j’esp`re que vous r´alisez que e e eseuls les boeufs proc`dent de la sorte. eLe castLe seul moyen de vous sortir de l` est d’effectuer un cast, c’est ` dire une conversion de type sur com- a amande. On caste en pla¸ant entre parenth`se le type dans lequel on veut convertir juste avant l’op´rande c e eque l’on veut convertir. Par exemple, 17
  19. 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 cop´rande, j, est aussi convertie en float. La division est donc une division flottante. Notez bien que le ecast est un op´rateur unaire, donc prioritaire sur la division qui est un op´rateur binaire, c’est pour ¸a e e cque la conversion de i a lieu avant la division. Mais si jamais il vous vient l’id´e saugrenue d’´crire e eint 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 emais comme la division a lieu avant toute conversion, c’est le r´sultat d’une division enti`re qui est converti e een flottant, vous avez donc le mˆme r´sultat que si vous n’aviez pas du tout cast´. e e e1.3.6 Les priorit´s eAjoutons 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. 20. 1.4 Traitements conditionnelsOn appelle traitement conditionnel un portion de code qui n’est pas ex´cut´e syst´matiquement, c’est ` e e e adire des instructions dont l’ex´cution est conditionn´e par le succ`s d’un test. e e e1.4.1 Si ... AlorsPrincipeEn algorithmique un traitement conditionnel se r´dige de la sorte : e si condition alors instructions finSi 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 eL’ex´cution de l’algorithme se poursuit alors en ignorant les instructions se trouvant entre le alors eet 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 eComparaisonsLa formulation d’une condition se fait souvent ` l’aide des op´rateurs de comparaison. Les op´rateurs de a e ecomparaison disponibles sont : – == : ´galit´ e e – != : non-´galit´ e e – <, <= : inf´rieur `, respectivement strict et large e a – >, >= : sup´rieur `, respectivement strict et large e aPar 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 ule 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 eprintf("Vous avez saisi une valeur nullen.") sera bien ex´cut´e. Si le test n’est pas v´rifi´, les e e e einstructions du bloc ... suivant le if sont ignor´es. e 19
  21. 21. Si ... Alors ... SinonIl 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 finLes 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 ed´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 etionnel ´tendu de la sorte : ei 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 eleurs !.Connecteurs logiquesOn formule des conditions davantage ´labor´es en utilisant des connecteurs et et ou. La condition A et e eB 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 esi 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 evoici 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. 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 superfluesLorsqu’une seule instruction d’un bloc if doit ˆtre ex´cut´e, les accolades ne sont plus n´cessaires. Il est e e e epossible 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 eEn 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 emax = ( 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 edans 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 epar cette instruction.1.4.2 SwitchLe switch en C s’´crit, avec la syntaxe suivante : e 21
  23. 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 deson num´ro, on ´crit e eswitch ( 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 eUne variable bool´enne ne peut prendre que deux valeurs : vrai et f aux. Il n’existe pas de type bool´en e ea` proprement parler en C. On utilise des int pour simuler le comportement des bool´ens. On repr´sente e ela valeur bool´enne f aux avec la valeur enti`re 0, toutes les autres valeurs enti`res servent ` repr´senter e e e a evrai.Utilisation dans des ifLorsqu’une condition est ´valu´e, par exemple lors d’un test, cette condition prend ` ce moment la valeur e e avrai 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 etoutes 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 ele test if (8) est toujours v´rifi´. Par contre le test if (0) n’est jamais v´rifi´. e e e eLa valeur vraiMˆ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 ex = (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 aest ´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 evaleur est affect´e ` x. e a 22

×