Bases en langage C.docx

BASE EN LANGAGE C 1.1 Historique Le langage C est né en 1972 dans les Bell Laboratories. Il fut inventé par les deux ingénieurs Dennis Ritchie et Brian Keringhan pour concevoir un système d'exploitation UNIX portable. En 1978 Keringhan et Ritchie publièrent une description définitive du langage connue par K&R-C. La popularité de ce nouveau langage fut impressionnante dans les années 80 à un tel point que de nouvelles implémentations du langage furent conçues et étaient incompatibles entre elles et avec le K&R-C. En conséquence le American National Standard Institute (ANSI) developpa une version standarisée du C connue sous le nom de ANSI-C. 1.2 Caractéristiques du langage C Comme déjà évoqué la popularité du C est due principalement à ses caractéristiques: * Universalité: Le langage C n'est pas spécifique à un domaine d'applications précis tel que COBOL (pour les applications mettant en jeu de grandes quantités de données) ou FORTRAN (applications scientifiques), par contre son utilisation est possible pour tout type d'applications. * Simplicité Le noyau du langage C est formé d'un nombre limité mais efficace d'opérateurs et de fonctions. * Modernité La programmation en C peut être qualifiée de moderne du fait que C est un langage structuré. * Rapidité C peut produire des programmes aussi rapides que ceux écrits en assembleur. * Portabilité Il existe des compilateurs C pour tout type de machines et de systèmes d'exploitation, ainsi un programme C peut être utilisé sur différents ordinateurs simplement en le recompilant (notez qu'avec les environnements graphiques de plus en plus commums la portabilité devient presque impossible). 2.1 Structure d’un programme C Un programme écrit en C doit obéir à certaines règles bien définies. Le langage reconnaît uniquement la structure de fonction: un programme écrit en C est un ensemble de fonctions dont chacune peut s’appeler elle-même et appeler les autres fonctions. Une fonction particulière, dont la présence dans le programme est obligatoire, est la fonction main . Le programme commencera toujours sont éxécution au début de cette fonction. La structure la plus simple d’un programme C est alors: main( ) { définition des variables instructions } Remarquez les parenthèses obligatoires après le nom de la fonction (ici main ) et les accolades d’ouverture et de fermeture délimitant le début et la fin de la fonction. 2.2 Les commentaires en C Dans un programme C il est possible (et d’ailleurs préférable) d’ajouter des commentaires facilitant ainsi la lecture et la compréhension du programme par le programmeur lui-même et par les autres personnes aussi. Le début d’un commentaire est marqué par /* et sa fin par */, notons que les commentaires imbriqués sont interdits. Exemple: /* ce programme est écrit en C */ ce commentaire est bon. /* ceci /* est faux */ donc à éviter */ tandis que celui-ci est faux. 2.3 Les fonctions précompilées et les header files Il existe en C des fonctions précompilées qui peuvent être incluses dans nos programmes, ces fonctions sont contenues dans des fichiers spéciaux appelés library files (extension *.lib). Pour accéder à ces fonctions une directive doit être issue au compilateur indiquant d’inclure les header files (extension *.h) contenant les déclarations correspondantes à ces fonctions. La syntaxe de la directive est la suivante: #include Cette directive doit être écrite au tout début du programme. Exemple: #include main( ) { printf("Hello world"); } Où stdio.h est le header file contenant la déclaration de la fonction printf. Nous reparlerons des header files et des fonctions dans les chapitres suivants. 2.4 Représentation des données en C L’ordinateur a besoin de manipuler et de stocker les données qu’on lui fourni. Le langage C permet la représentation des données sous différents formats répondant ainsi à ces besoins. Les différents types de données sont les suivants: 2.4.1 Les constantes définition: les constantes sont des données dont la valeur ne peut pas être modifiée durant l’éxécution du programme. En C on a les types de constantes suivants: 2.4.1.1 Les constantes entières Ce sont tout simplement des valeurs entières. Exemple: -5 124 2.4.1.2 Les constantes réelles Ce sont des valeurs représentées en virgule-flottante. Exemple: -12.36               123.21               134.1e+3               111.12E-6 2.4.1.3 Les constantes caractère Elles représentent un seul caractère. Exemple: ‘a’               ‘B’               ‘2’ Le caractère étant un des caractères du code ASCII à l’exception de l’apostrophe et du backslash. Notez que dans une constante caractère le caractère est entouré de deux apostrophes. Remarque: dans le troisième exemple le ‘2’ représente le caractère 2 et non pas l’entier 2 ( en ASCII le caractère 2 a pour code numérique 50 en décimal). 2.4.1.4 Les constantes séquences d’échappement Elles représentent des caractères speciaux. Une séquence d’échappement est formée du caractère backslash suivi d’un autre caractère. Les principales séquences d’échappement sont les suivantes:                                 \n                 saut de ligne                                 \t                  tabulation:pousser de 5 caractères                                 \b                 effacer un caractère (backspace)                                 \a                 alerte:bip sur le haut parleur                                 \\                  imprime le caractère backslash                                 \’                  imprime l’apostrophe 2.4.1.5 Les constantes chaînes de caractères Une chaîne de caractères représente un suite de caractères et de séquences d’échappement délimitée par de guillemets. Exemple: "Je suis une chaîne \n" 2.4.2 Les variables définition: Les variables sont des données dont la valeur peut être modifiée durant l'éxécution du programme. Toute variable est représentée par un indentificateur qui doit être déclaré avant son utilisation. La déclaration se fait de la manière suivante: type identificateur = valeur; type étant un des types reconnus par le langage C identificateur étant le nom par lequel on désignera la variable valeur étant la valeur initiale qu'on souhaite attribuer à la valeur. Si dans la déclaration la variable n'est pas initialisée (on ne lui attribut pas de valeur initiale) cette dernière peut alors contenir n'importe quoi. En ce qui concerne l'identificateur il doit obeir aux règles suivantes: -Il peut être composé de n'importe quelle combinaison de lettres et de chiffres mais doit nécessairement commencer par une lettre ou un trait de soulignement (underscore). -La longeur maximale de l'identificateur dépend du compilateur (32 caractères en Borland C). -Les lettres minuscules sont différenciées des majuscules ainsi somme et SOMME sont deux identificateurs différents et peuvent être utilisés dans le même programme. Il est temps de parler des différents types de variables que C nous présente. En C les types de données sont: 2.4.2.1 Le type char Il permet de déclarer un variable comme caractère. Exemple: char c='a'; 2.4.2.2 Le type int Il permet de déclarer un variable comme entier positif ou négatif. Exemple: int a=200; Remarque: Un int doit être compris entre deux valeurs limites (conséquence de l'architecture de l'ordinateur), sur le PC par exemple entre -32768 et 32767. 2.4.2.3 Le type float Il permet de déclarer une variable comme réel en virgule-flottante compris entre -10e38 et 10e38. Exemple: float b=2.32e+3; 2.4.2.4 Le type double Même que float mais pour des nombres compris entre -10e308 et 10e308. 2.4.3 Les tableaux Définition: Les tableaux constituent un moyen pratique qui permet de regrouper plusieurs variables de même type. la déclaration d'un tableau se fait de la manière suivante: type identificateur[constante entière positive]; Exemple: int tab[4]; déclare un tableau de 4 valeurs entières.   tab[0] tab[1] tab[2] tab[3]   On peut accéder aux éléments individuels du tableau en indiquant entre les crochets l'indice correspondant à cet élément. Notons que l'indice du premier élément est 0 et non pas 1. ainsi tab[0] indique le premier élément           .           .           .         tab[3] indique le dernier élément   La déclaration des tableaux ne se limite pas à une seule dimension, en effet on peut déclarer des tableaux à plusieurs dimensions. Exemple: char tab[5][3]; déclare un tableau de 5*3=15 éléments tab[0][0]             tab[2][1]             tab[4][2]  Le premier indice est le numéro de la ligne et le second celui de la colonne.   Comme toute autre variable un tableau peut être initialisé durant sa déclaration. Exemple: int tab[3]={0,1,2};   0 1 2                     int tab[2][2]={ {1,2},{3,4} }; 1 2 3 4                 int tab[4]={1,2}; ici les deux premiers éléments du tableau sont initialisés. Notons qu'on peut pas commencer l'initialisation par les derniers éléments du tableau. 2.4.4 Les structures Définition: Si un tableau permet de regrouper des variables de même type, une structure permet par contre de regrouper des variables de types différents. La déclaration d'une structure se fait de la façon suivante: struct identificateur     {         type élément 1;         type élément 2;             .             .             .         type élément n;     }; Les éléments de la structure sont appelés les champs ou les membres de cette structure. Notons que les structures constituent un moyen pratique de regrouper des éléments qui sont en relation. Exemple:  struct client                 {                     char nom[20];                     int numero;                 }; Pour accéder à un champ d'une structure l'opérateur " . " est utilisé. Exemple: client.numero  permet d'accéder au champ numéro dans client. Après avoir déclaré une structure on peut directement déclarer des variables de ce type de structure. Exemple:  struct client                 {                     char nom[20];                     int numero;                 };                 struct client  client1,client2; donc client1 et client2 sont des structures client. La déclaration de variables de type structure peut aussi se faire durant la déclaration de la structure. Exemple:  struct client                 {                     char nom[20];                     int numero;                 }client1,client2; client1 et client2 sont deux structures indépendantes, on peut accéder aux champs de chacune d'elle les modifier et les traiter.   Chapitre 3: Les opérateurs Le langage C est basé sur un noyau d'opérateurs simple mais assez important et efficace permettant d'écrire des expressions réduites aboutissant à des calculs rapides. Avant de commencer la discussion sur les opérateurs il est nécessaire de clarifier et d'expliquer les mots utilisés après: Les constantes et les variables déclarées dans le programme constituent les données manipulées par l'ordinateur. Les opérateurs ont pour but de permettre la manipulation et le traitement de ces données. Différentes données peuvent être groupées à l'aide des opérateurs pour former des expressions. Explication faite passons à la discussion des différents opérateurs du langage C. Il existe en C différentes catégories d'opérateurs. 3.1 Opérateurs arithmétiques Ils permettent d'écrire des expressions mathématiques mettant en jeu des opérandes numériques. plus unaire + : Il permet de signaler une valeur positive. Exemple: a= +200;                a= +(200-c); moins unaire -: Il permet de signaler une valeur négative. Exemple: a= -32;                a= -b; plus binaire +: Il retourne la somme de ses deux opérandes. Exemple: a= 2+3;                a= b+c; moins binaire -: Il retourne la différence de ses deux opérandes. Exemple: a= 41-12;                a= b-c; multiplication *: Cet opérateur multiplie ses deux opérandes. Exemple: a= 30*12;                a= c*b; division /: Cet opérateur divise son premier opérande par le second. Exemple: a= 4/2;                a= c/b; Remarque: il est trés important de noter que la division de deux entiers retourne un entier. Ainsi a=5/6; retourne 0 et non pas 0.83333...  . Pour remedier à ce problème il faut que l'un des opérandes soit un réel par suite a= 5.0/6; retournera comme réponse 0.83333... . modulo %: Il retourne le reste de la division du premier opérande par le second. Exemple: a=129%5; retourne 4 car  129= 5*25 + 4. 3.2 Opérateurs logiques Ils permettent de réaliser des expressions logiques ou booléennes, permettant ainsi de former des expressions complexes à partir d'expressions simples. négation ! décrite par la table qui suit.   A  !A  vrai  faux  faux  vrai   ET logique && décrit par la table qui suit.   A  B  A&&B  vrai  vrai  vrai  vrai  faux  faux  faux  vrai  faux  faux  faux  faux  OU logique || décrit par la table qui suit.   A  B  A||B  vrai  vrai  vrai  vrai  faux  vrai  faux  vrai  vrai  faux  faux  faux  Notons que A et B représentent des expressions et que le résultat de telles opérations est 0 pour faux et 1 pour vrai. Nous reviendrons sur ces opérateurs plus tard dans les autres chapitres et les exercises. 3.3 Opérateurs relationnels Ils permettent de former des expressions de contrôle en comparant les deux opérandes.   infériorité stricte <  infériorité large <=  supériorité stricte >  supériorité large >=  égalité = =  inégalité !=    3.4 Opérateurs d'affectation   affectation simple =  affectation avec calcul arithmétique.  ces opérateurs effectuent le calcul arithmétique de leur premier opérande avec le second en l'affectant au premier. + = - = * = / = %= Exemple: a +=b; equivaut à a=a+b;  incrémentation.  ajoute 1 à son opérande. + + Exemple: a++; equivaut à a= a+1;  décrémentation - -  Remarque: lorsque l'opérateur d'incrémentation ou de décrémentation est placé avant son opérande ce dernier est incrémenté avant d'être utilisé dans l'expression, c'est la pré-incrémentation. lorsque l'opérateur d'incrémentation ou de décrémentation est placé après son opérande ce dernier est incrémenté après son utilisation dans l'expression, c'est la post-incrémentation. 3.5 L'opérateur conditionnel ou ternaire Le seul opérateur ternaire du langage C est l'opérateur ?:  aussi appelé l'opérateur conditionnel. Il évalue son second ou son troisième opérande selon que sont premier opérande est vrai ou faux. Sa syntaxe est la suivante: opérande1?opérande2:opérande3 Exemple: a= (c>b)?12:15 Si la variable c est supérieure à la variable b alors la variable a sera égale à 12 sinon elle sera égale à 15. 3.6 Autres opérateurs L'opérateur . permet comme nous l'avons vu dans le chapitre précédent d'accéder au champs d'une structure. L'opérateur d'évaluation séquentielle noté , permet tout simplement d'évaluer ses deux opérandes dans l'ordre de gauche à droite. Exemple: a= (b++,b+12);   incrémente b, effectue la somme b+12 puis affecte le résultat à a. 3.7 Priorité et ordre d'évaluation des opérateurs Peut être que vous vous posez déjà la question suivante: comment évalue t'on une expression si elle contient plusieurs opérateurs? En fait dans le langage C chaque opérateur a sa priorité et son ordre d'évaluation. Dans une expression comportant plusieurs opérateurs ceux de plus grande priorité sont évalués en premier ensuite ceux de priorité plus petite et ainsi de suite jusqu'à arriver à ceux dont la priorité est la plus petite. Dans le cas où plusieurs opérateurs sont de même priorité leur ordre d'évaluation détermine alors celui qui sera évalué en premier. Je vous présente ci-dessous un tableau de priorité et d'ordre d'évaluation des différents opérateurs:   Opérateur  Ordre d'évaluation  ( )   [ ]   . Gauche --> Droite  !   + +   --   - (moins unaire)  Droite --> Gauche  *   /   %  G --> D  +   -  G --> D  <   <=   >   >=  G --> D  = =    !=  G --> D  &&  G --> D  ||  G --> D  ?:  G --> D  =   + =   -=   * =   /=   %=  D --> G  , G --> D  3.8 Les conversions de type 3.8.1 La conversion implicite ou automatique Si on regroupe dans une même expression des types de données différents le compilateur procède à une conversion des types selon la règle suivante: Le type dont le poids est le plus faible est converti au type dont le poids le plus fort. Ainsi un char en présence d'un int sera convertit en int (la valeur correspondante sera alors le code ASCII du caractère correspondant), un int en présence d'un float sera convertit en float. Le type dont le poids est le plus fort est le double. Exemple: char a='A';                int    b=32;                alors a+b sera un int contenant 97 car le char a été convertit en int. Il est aussi important de noter que dans une expression d'affectation le compilateur procède à une conversion implicite en changeant le type de la variable à droite au type de la variable à gauche. Exemple: int a=12;               float b=a;   alors b sera égale à 12.0              int c=b;      alors c sera égale a 12 et la valeur décimale est tronquée. 3.8.2 La conversion explicite ou forcée Nous avons vu que le compilateur procède à une conversion quand cette conversion lui paraît logique: int --> float par exemple. Cepandant il est tout à fait possible de procéder à la conversion d'un float en un int par exemple. Cette conversion est dite une conversion forcée ou explicite. Une conversion forcée peut être achevée en utilisant un cast, la syntaxe d'un cast est la suivante: (type souhaité) expression Exemple: (int)(5.31/5) retournera un int (valeur tronquée), en effet 5.31/5 retourne un float mais puisque un cast est utilisé avant l'expression le float sera convertit en int. Chapitre 4: Les fonctions d'entrées/sorties en C Après avoir exploré les types de données et les opérateurs du langage C nous passons maintenant à l'étude de quelques fonctions qui vont nous permettre de lire à partir du clavier et d'afficher sur l'écran de notre ordinateur. Après tout, tout programme aura besoin de données que nous devons lui fournir pour les manipuler et affichera en retour différents résultats sur l'écran. 4.1 #include Le langage C nous fournit des fonctions prédéfinies de lecture à partir du clavier et d'écriture sur l'écran qui sont contenues dans le "header file" stdio.h donc au début de tout programme qui devra utiliser ces fonctions nous devrons inclure au début la directive suivante: #include 4.2 La fonction getchar(); La fonction getchar permet la récupération d'un seul caractère à partir du clavier. La syntaxe d'utilisation de getchar est la suivante: variable=getchar(); notez que variable doit être de type char et les parenthèses aprés getchar. Exemple: #include main() { char c; c=getchar(); }   4.3 La fonction putchar(); La fonction putchar permet l'affichage d'un seul caractère sur l'écran de l'ordinateur. La fonction putchar constitue alors la fonction complémentaire de getchar. La syntaxe d'utilisation est la suivante: putchar(variable); où variable est de type char. Exemple: #include main() { char c; c=getchar(); putchar(c); } Cet exemple attend l'entrée d'un caractère à partir du clavier et l'affiche sur l'écran.   4.4 La fonction scanf(); Les deux fonctions déjà évoquées bien qu'utiles présentent un incovénient majeur: que faire pour pouvoir entrer une chaîne complète ou même un nombre? Dans le cas d'un chaîne on devra construire une boucle et dans le cas d'un nombre on devra aussi convertir les caractères en chiffres, tout celà se montre très lourd. c'est alors que vient à l'aide la fonction scanf. En effet elle permet de récupérer n'importe quelle combinaison de valeurs numériques, de caractères et de chaînes. La syntaxe d'utilisation de scanf est la suivante: scanf(chaîne de contrôle, var1, var2, ..., varN); "où chaîne de contrôle" représente certaines données de formattage et "var1,  var2,..., varN" représentent les variables à remplir. La chaîne de contrôle est entourée de guillemets constituée de groupes de caractères chaque groupe étant en relation avec une des variables mentionnées. Le groupe devra commencer par le signe % suivit d'un nombre indiquant la largeur de la variable à lire et ensuite un caractère bien défini (le type) indiquant si la variable est un caractère, un nombre (soit entier soit décimal) ou une chaîne. La syntaxe du groupe possède alors la forme générique suivante: %[largeur]type Notez que l'argument entre crochets est facultatif. Les différents types sont donnés dans le tableau suivant. Type Données à récupérer c caractère d nombre entier e ou f un nombre décimal en notation réelle (f) ou exponentielle (e) s une chaîne de caractères Si la chaîne contient plus qu'un groupe il sont souvent séparés par des espaces et ainsi les données entrées doivent être séparées par des espaces. Le type de chaque variable doit correspondre au type de son groupe et chaque variable doit être précédée du signe & sauf si elle est une chaîne. Théorie difficile? passons aux exemples: 1) i est un entier. Pour obtenir i de l'utilisateur on écrit: scanf("%d",&i); sur le clavier nous tapons: -->> 123 2) a est un caractère: scanf("%c",&a); -->> d 3) ville est une chaîne: scanf("%s",ville);                      ^                       |------------ pas de & car ville est une chaîne. -->> beyrouth 4) i et j sont deux entiers. i ne doit pas être plus large que trois chiffres: scanf("%3d %d",&i,&j); -->> 231 1024              ^               |---------- notez l'espace separateur   4.5 La fonction printf(); Comme la fonction scanf(); permet d'acquérir tout type de données à partir du clavier, la fonction printf(); permet quant à elle d'afficher tout type de données à l'écran de l'ordinateur. Cette fonction permet d'afficher n'importe quelle combinaison de caractères de nombres et de chaînes. La syntaxe de la fonction printf(); est la suivante: printf("chaîne de contrôle,arg1, arg2,..., argN); où "chaîne de contrôle" représente certaines données de formattage et "arg1, arg2,..., argN" les variables (ou éventuellement les expressions) à afficher. chaque groupe est en relation avec l'argument correspondant dans la liste des arguments. Le groupe possède la forme générique suivante: %[flag][largeur].[précision]type Les éléments entre crochets étant facultatifs. La largeur indique le nombre minimum de caractères affichés et la précision indique le nombre maximum de caractères affichés (pour un nombre décimal la précision indique le nombre maximal de caractères aprés la virgule qui est par défaut 6) Les differents types sont donnés dans le tableau suivant: Type Signification c un caractère d un entier f un réel s une chaîne de caractères e notation exponentielle Les différents "flags" sont donnés dans le tableau suivant: Flag Signification valeur par défaut - justification à gauche justification à droite + affichage du signe (+ ou -)avant la valeur numérique uniquement le - est affiché espace les valeurs positives sont précédées d'un espace aucun espace n'est affiché Chapitre 5: Les instructions du langage C Le langage C dispose d'un nombre d'instructions faible mais certainement efficace. Par défaut les instructions sont éxécutées séquentiellement et cet ordre peut être modifié par les instructions de contrôle et de boucle ainsi que les instructions d'échappement. Nous allons dans ce chapitre examiner successivement les instructions de base, celles de boucle et enfin celles d'échappement.  5.1 Les instructions de base Les instructions de base sont éxécutées séquentiellement selon l'ordre de leur apparition dans le programme. Elles ne modifient pas l'ordre d'éxécution du programme. On constate deux types d'instructions de base: l'instruction simple et le bloc d'instructions.  5.1.1 Instruction simple Une instruction simple est toute instruction suivie d'un point-virgule. La syntaxe est la suivante: expression;   Exemple: prix_total=prix_unitaire * quantite; 5.1.2 Bloc d'instructions Un bloc d'instructions peut être utilisé n'importe où une instruction simple peut apparaître. Généralement un bloc d'instructions est formé d'une suite d'instructions délimitée par des accolades. La syntaxe est alors: { instruction1; instruction2;      .      .      . instructionN; } Notez qu'après l'accolade fermante il n'y a pas de point-virgule. L'utilité du bloc d'instructions sera evidente quant il sera utilisé avec les instructions de contrôle et de boucle.    5.2 Les instructions de contrôle et de boucle Les instructions de contrôle permettent de modifier l'ordre d'éxécution séquentiel des instructions. On peut ainsi dérouter l'éxécution selon qu'une condition est vraie ou fausse.  5.2.1 L'instruction if-else L'instruction if permet l'éxécution d'une instruction ou d'un bloc d'instructions si et seulement si la condition qui est une expression logique est vérifiée. La syntaxe est la suivante: if(condition)  instruction;     /* ou éventuellement un bloc d'instructions */   Pour illustrer la théorie prenons un exemple: if(note > 15)  groupe='A'; If peut être aussi utilisée avec else (qui est facultative) et ainsi si la condition est vérifiée l'instruction (ou le bloc d'instructions) directement après le if sera éxécutée sinon (condition fausse) l'instruction (ou le bloc d'instructions) après le else sera éxécutée. La syntaxe complète de l'instruction if-else sera alors: if(condition)  instruction; else  autre_instruction;   Exemple: if(note > 15)  groupe='A'; else  groupe='B'; Les instructions if-else peuvent être imbriquées l'une dans l'autre. Lors d'une telle situation un else se rapporte toujours au premier if qui le précède. Il est conseillé d'espacer les paires de if-else horizontalement l'une de l'autre pour assurer la clareté de la lecture. Exemple: if(condition1)  if(condition2)   instruction1;  else instruction2; instruction3; Lorsque condition1 n'est pas vérifiée c'est instruction3 qui est éxécutée sinon condition2 est testée si elle est vraie instruction1 est éxécutée et si elle est fausse instruction2 est éxécutée. Le else se rapporte ainsi au second if. A noter que l'utilisation des accolades changera la règle du else correspondant au premier if qui le précède. Exemple: if(condition1)  {  if(condition2)  instruction1;  } else instruction2; instruction3; Lorsque condition1 n'est pas vérifiée instruction2 est éxécutée puis instruction3, sinon si condition2 est vérifiée instruction1 est éxécutée puis instruction3. Le else se rapporte dans ce cas au premier if. 5.2.2 L'instruction switch Imaginez qu'on veut imprimer à l'écran un des caractères A, B, C, D, E ou F selon le chiffre entré par l'utilisateur et selon le principe suivant: 1 --> A 2 --> B 3 --> C 4 --> D 5 --> E 6 --> F L'écriture de ce raisonnement en une suite d'instructions if-else est, quoique faisable, gênante. C'est ici que l'utilisation de l'instruction switch peut paraître utile. En effet cette instruction permet de sauter directement vers l'instruction correcte selon la valeur d'une variable appelée sélecteur. La syntaxe est la suivante: switch(sélecteur) { case cas1: instruction1; case cas2: instruction2;            .            .            . case casN: instructionN; default: instruction_par_défaut; /* le cas "default" étant facultatif */ } Notez qu'il n'y a pas de point-virgule après l'accolade de fermeture. Le fonctionnement est le suivant: Lorsque le selecteur (qui peut en effet être une expression ou une variable) donne un résultat identique à celui d'une certaine ligne commencant par case, un saut est éffectué vers cette ligne et l'instruction(s) correspondante(s) est (sont) éxécutée(s). Par suite toutes les autres lignes commencant par case auront leurs instructions correspondantes éxécutées. Lorsqu'aucun cas n'est valide un saut est éffectué vers la ligne commencant par default (si elle existe) et les instructions correspondantes seront éxécutées.   Notre exemple s'écrit alors: switch(choix) { case 1: printf("A"); case 2: printf("B"); case 3: printf("C"); case 4: printf("D"); case 5: printf("E"); case 6: printf("F"); default: printf("autre."); } L'entrée par un utilisateur du choix 1 donnera en sortie: ABCDEFautre. Nous constatons que l'éxécution des autres instructions après celle qui correspond au bon choix semble être gênante (au lieu d'afficher A on affiche ABCDEFautre.) ; Ne craignez rien le remède existe: c'est l'instruction break (plus de details plus tard). 5.2.3 L'instruction while L'instruction while permet l'éxécution répétée d'une instruction ou d'un bloc d'instructions tant qu'une certaine condition est vraie. La syntaxe est la suivante: while(condition)  instruction; Le fonctionnement est le suivant: lorsque l'instruction while est rencontrée la condition entre parenthèses est testée; si elle est vraie alors l'instruction ou le bloc d'instructions après le while est éxécuté(e) et la condition est testée à nouveau; si elle reste vraie le cycle sera répété à nouveau jusqu'à ce que la condition devienne fausse; l'éxécution continue alors directement à la première instruction après le while.   Exemple: i=1; while(i<10) { printf("à l'intérieur du while\n"); i++; } printf("à l'extérieur du while\n");   à l'écran on aura alors: à l'intérieur du while à l'intérieur du while à l'intérieur du while à l'intérieur du while à l'intérieur du while à l'intérieur du while à l'intérieur du while à l'intérieur du while à l'intérieur du while à l'extérieur du while Remarque: il faut toujours s'assurer que la condition sera à un certain moment fausse sinon on restera dans la boucle while indéfiniment. Dans notre exemple c'est l'instruction i++; qui assurera celà. 5.2.4 L'instruction do-while L'instruction do-while est presque identique à l'instruction while. La différence est que dans le do-while la condition est testée après avoir éxécuter l'instruction ou le bloc d'instructions annexe. La syntaxe est la suivante: do instruction; while(condition); Lorsque do est rencontré l'instruction est éxécutée puis la condition est testée, si elle est vérifiée la boucle est répétée sinon l'éxécution continue à la première instruction après le while.   Exemple: i=1; do { printf("%d ",i); i++; }while(i<10); Sur l'écran on obtient 1 2 3 4 5 6 7 8 9 5.2.5 L'instruction for L'instruction for permet l'éxécution répétitive d'une instruction ou d'un bloc d'instructions un nombre bien déterminé de fois et celà grâce a un compteur. La syntaxe est la suivante: for(initialisation; condition; incrémentation) instruction; Le fonctionnement est le suivant: Lorsque for est rencontrée pour la première fois dans un programme, la partie initialisation est éxécutée en premier. La partie initialisation permet en effet de donner au compteur unr valeur initiale. Puis la condition est testée, si elle est vérifiée instruction est éxécutée sinon le programme saute à l'instruction immédiatement après le for. Après éxécution de instruction, la partie incrémentation est éxécutée, elle permet en effet de changer la valeur du compteur. A nouveau condition est testée et la boucle se répète à nouveau tant que condition reste vraie. Notez que initialisation ne s'effectue qu'une seule et unique fois durant tout le passage par la boucle for et celà au tout début.   Exemple: for(i=1;i<10;i++)  printf("bonjour\n"); Cette boucle sera itérée 9 fois et ainsi bonjour sera affiché 9 fois. 5.3 Les instructions d'échappement Ces instructions permettent d'interrompre la séquence normale d'éxécution des instrcutions surtout les instructions de contrôle et de boucle.  5.3.1 L'instruction break L'instruction break n'a de signification que lorsqu'elle est utilisée à l'intérieur de l'une des instructions suivantes: while, switch, do-while et for. Lorsqu'lle est est rencontrée un saut est effectué à la première instruction après l'instruction de contrôle qui la contient. La syntaxe est la suivante: break; Prenons quelques exemples.   Exemple 1: int i=1; while(i!=0)   /* boucle infinie */ { a=getchar(); if(a=='x')  break; } Lorsque la touche x est tapée au clavier l'instruction break est éxécutée et la sortie de la boucle while infinie est effectuée. Exemple 2: Rappelez vous que dans l'exemple du sawitch au paragraphe 5.2.2 on avait le problème que les instructions après la bonne instruction étaient elles aussi éxécutées. Le remède est alors d'utiliser le break. Reprenons l'exemple en le rectifiant: switch(choix) { case 1: printf("A"); break; case 2: printf("B"); break; case 3: printf("C"); break; case 4: printf("D"); break; case 5: printf("E"); break; case 6: printf("F"); break; default: printf("autre."); /* break non nécessaire */ } Ainsi lorsque la bonne instruction est éxécutée un break est rencontré ce qui permet de sortir directement du switch. 5.3.2 Instruction continue L'instruction continue n'a de signification que lorsqu'elle est utilisée au sein d'une des boucles suivantes: while, do-while et for. Lorsqu'elle est rencontrée le programme passe directement à l'itérantion suivante de la boucle où elle se trouve sans effectuer les instructions restantes du passage actuel. La syntaxe est la suivante: continue;   Exemple: for(j=1;j<=4;j++) { if(j!=2)  printf("%d\n",j); else continue; } A l'écran on voit s'afficher: 1 3 4 5.3.3 L'instruction nulle Cette instruction ne réalise absoluement rien. La syntaxe est simplememt le point-virgule. Son utilité réside dans le fait qu'elle permet de perdre du temps. Elle est presque jamais utilisée.