Cours de C apprendre les bases de la programmation avec le langage c

Cours de C apprendre les bases de la programmation avec le langage c

…

Présentation du langage C

Historique

Langage de programmation développé en 1970 par Dennie Ritchie aux Laboratoires Bell d'AT&T. Il est l'aboutissement de deux langages :

• BPCL développé en 1967 par
  Martin Richards.
• B développé en 1970 chez AT&T par
  Ken Thompson.

Il fut limité à l'usage interne de Bell jusqu'en 1978 date à laquelle Brian Kernighan et Dennie Ritchie publièrent les spécifications définitives du langage : «~The C programming Language~».

Au milieu des années 1980 la popularité du langage était établie. De nombreux compilateurs ont été écrits, mais comportant quelques incompatibilités portant atteinte à l'objectif de portabilité. Il s'est ensuivi un travail de normalisation effectué par l'ANSI (American National Standard Institue) qui a abouti en 1988 avec la parution par la suite du manuel : «~The C programming Language - 2ème édition~».

Intérêts du langage

• Langage polyvalent permettant le développement de systèmes d'exploitation, de programmes applicatifs scientifiques et de gestion.
• Langage structuré.
• Langage évolué qui permet néanmoins d'effectuer des opérations de bas niveau («~assembleur d'Unix~»).
• Portabilité (en respectant la norme !) due à l'emploi de bibliothèques dans lesquelles sont reléguées les fonctionnalités liées à la machine.
• Grande efficacité et puissance.

Qualités attendues d'un programme

• Clarté
• Simplicité
• Modularité
• Extensibilité

2. Généralités
   • Jeu de caractères

Le jeu de caractères utilisé pour ecrire une programme est composé de :

• 26 lettres de l'alphabet (minuscules, majuscules)
• chiffres 0 à 9
• séquences d'échappement telles :
  • passage à la ligne (\n),
  • tabulation (\t),
  • backspace (\b).

• caractères spéciaux :

Structure d'un programme C

• Un Programme C :
  est un fichier source entrant dans la composition d’un programme exécutable est fait d’une succession d’un nombre quelconque d'éléments indépendants, qui sont :

• des directives pour le préprocesseur (lignes commençant par #),
• des constructions de types (struct, union, enum, typedef ),
• des déclarations de variables et de fonctions externes,
• des définitions de variables et
• des définitions de fonctions dont l'une doit s'appeler main et apparaître obligatoirement dans le programme.

• Une Fonction est formé:
  • d’entête (type et nom de la fonction suivis d'une liste d'arguments entre parenthèses),
  • instruction composée constituant le corps de la fonction.

• Instruction composée : délimitée par les caractères { et }
• Instruction simple : se termine par ;

• commentaire : encadré par les délimiteurs /* et */
• Instruction préprocesseur : commence par #

Exemple :

#include<stdio.h>

#define  PI 3.14159

/*  calcul de la surface d'un cercle */

main()

{

  float rayon, surface;

  float calcul(float rayon);

  printf("Rayon = ? ");

  scanf("%f", &rayon);

  surface = calcul(rayon);

  printf("Surface = %f\n", surface);

}

/* définition de fonction */

float calcul(float r)

{

/* définition de la variable locale */

  float a;

  a = PI * r * r;

  return(a);

}

• Compilation et édition des liens

La transformation d’un texte écrit en langage C en un programme exécutable par l’ordinateur se fait en deux étapes : la compilation et l'édition de liens.

La compilation est la traduction des fonctions écrites en C en des procédures équivalentes écrites dans un langage dont la machine peut exécuter les instructions. Le compilateur lit toujours un fichier, appelé fichier source, et produit un fichier, dit fichier objet.

Chaque fichier objet est incomplet, insuffisant pour être exécuté, car il contient des appels de fonctions ou des références à des variables qui ne sont pas définies dans le même fichier. Par exemple, le premier programme que vous écrirez contiendra déjà la fonction printf que vous n’aurez certainement pas écrite vous-même. L'édition de liens est l’opération par laquelle plusieurs fichiers objets sont mis ensemble pour se compléter mutuelle­ment : un fichier apporte des définitions de fonctions et de variables auxquelles un autre fichier fait référence et réciproquement. L'éditeur de liens (ou linker) prend en entrée plusieurs fichiers objets et bibliothèques (une variété particulière de fichiers objets) et produit un unique fichier exécutable.

• Identificateurs et mots-clés

• Identificateur :
  nom donné aux diverses composantes d'un programme ; variables, constante, tableaux, fonctions.
  • Formé de lettres et de chiffres ainsi que du caractère _ permettant une plus grande lisibilité. Le 1^er caractère doit obligatoirement être une lettre ou bien le caractère _.
  • Peut contenir jusqu'à 31 caractères minuscules et majuscules.
  • Les minuscules et les majuscules ne sont pas equivalentes : les identificateurs ligne et Ligne sont différents.

Exemples

• Identificateurs valides :

• Identificateurs invalides :

• Mots réservés (mots-clés)

Certains mots sont réservés par le langage car ils ont une signification particulière. Il est alors interdit d'utiliser un de ces mots comme identificateur. Bien que le compilateur fasse la différence entre majuscules et minuscules et qu'on puisse donc utiliser un de ces mots en majuscules comme identificateur, il est préférable, pour la clarté du source, d'éviter cette attitude de programmation.

• Les séparateurs

Les différents séparateurs reconnus par le compilateur peuvent avoir plusieurs significations.

• Les commentaires

Les commentaires permettent de porter des remarques afin de faciliter la lecture d'un programme source. Chaque commentaire est délimité par les combinaisons suivantes "/* Commentaire */" Les commentaires ne sont pas pris en compte par le compilateur et n'augmentent donc pas la taille des programmes exécutables.

Les commentaires peuvent tenir sur plusieurs lignes du style :

/*   Je commente mon programme Je continue mes commentaires J'ai fini mes commentaires             */

Les commentaires ne peuvent pas être imbriqués comme dans le style :

 /* Début Commentaire 1 /* Commentaire 2 */ Fin commentaire 1*/

Remarque :

Les compilateurs récents acceptent, comme commentaire, la séquence "//" spécifique au langage "C++" qui permet de ne commenter qu'une ligne ou une partie de la ligne.

// Cette ligne est totalement mise en commentaire

int i;  // Le commentaire ne commence qu'à la séquence "//"

• Les variables

Comme tout langage déclaratif, le langage C exige que les variables soient déclarées avant leur utilisation. En fait, pour chaque bloc d'instructions délimité par des accolades "{", il faut déclarer toutes les variables avant que soit écrite la première instruction du bloc. Mais cette règle étant valable pour chaque bloc ; on peut aussi déclarer des variables dans des sous-bloc d'instructions.

Exemple :

/* Bloc d'instruction n° 1*/

{

Déclaration des variables (avant toute instruction du bloc n° 1)

Instruction

Instruction

…

/* Sous-bloc d'instruction n° 2 */

{

Déclaration des variables (avant toute instruction du bloc n° 2)

Instruction

Instruction

…

}

…

Instruction appartenant au bloc n° 1

}

Une variable est définie par plusieurs attributs; certains facultatifs mais ayants alors une valeur par défaut) :

• sa classe d'allocation en mémoire ("auto" par défaut)
• en cas de variable numérique, l'indication "signé" ou "non-signé" (signé par défaut)
• le type de la valeur qu'elle doit stocker (entier par défaut, nombre en virgule flottante, etc.)
• son nom (l'identificateur de la variable)

Déclaration :

[classe] [unsigned/signed] <type> <identificateur>; (n'oubliez pas le point-virgule final)

Exemple :

static int nb;   // Déclaration d'une variable nb de type int de classe static

int i;           // Déclaration d'une variable i de type int (de classe auto par défaut)

Remarque :

la notion de classe sera revue plus en détail par la suite du cours. Jusque là, il suffira de ne pas spécifier de classe pour vos variables.

Lors de sa création en mémoire, une variable possède n'importe quelle valeur.

3. Élements de base pour debuter
   • Les types de base (types simples ou scalaires)

Un programme manipule des données de différents types sous la forme de constantes ou de variables. Les types de base correspondent aux types directement supportés par la machine. Dans le langage C, tout type de base est un nombre codé sur un ou plusieurs octets. Donc tout type de base accepte toute opération mathématique de base. Les principaux types de base sont:

• les entiers

• int : entier codé sur 2 ou 4 octets suivant la machine sur laquelle on travaille. Dans le monde Unix, il est généralement de 4 octets. Sa plage de valeur peut donc aller de :
  • -2³¹ à 2³¹ - 1 ; c'est à dire de -2 147 483 648 à 2 147 483 647 s'il est déclaré signé
  • 0 à 2³² - 1 ; c'est à dire de 0 à 4 294 967 296 s'il est déclaré non-signé
• short int : entier court codé sur 2 octets. Le mot "short" est suffisant par lui-même donc le mot "int" n'est pas obligatoire. Sa plage de valeur peut aller de :
  • -2¹⁵   à 2¹⁵  - 1 ; c'est à dire de -32 768 à 32 767 s'il est déclaré signé    
  • 0 à 2¹⁶ - 1 ; c'est à dire de 0 à 65 535 s'il est déclaré non-signé
• long int : entier long codé sur 4 octets. Le mot "long" est suffisant par lui-même donc le mot "int" n'est pas obligatoire. Sa plage de valeur peut aller de :
  • -2³¹ à 2³¹ - 1 ; c'est à dire de -2 147 483 648 à 2 147 483 647 s'il est déclaré signé
  • 0 à 2³² - 1 ; c'est à dire de 0 à 4 294 967 296 s'il est déclaré non-signé
• long long int : entier long codé sur 8 octets. Les mots "long long" sont suffisants par eux-mêmes donc le mot "int" n'est pas obligatoire. Sa plage de valeur peut aller de :
  • -2⁶³ à 2⁶³ - 1 ; s'il est déclaré signé
  • 0 à 2⁶⁴ - 1 ; c'est à dire de 0 à 18 446 744 073 709 551 615 s'il est déclaré non-signé
• char : caractère ASCII qui est un nombre entier codé sur 1 octet. Lui aussi de par sa nature numérique accepte des opérations mathématiques. Sa plage de valeur peut aller de :
  • -2⁷ à 2⁷ - 1 ; c'est à dire de -128 à 127 s'il est déclaré signé
  • 0 à 2⁸ - 1 ; c'est à dire de 0 à 255 s'il est déclaré non-signé

Remarques :

Ajouter 1 à une variable ayant atteint sa limite maximale la fait basculer en limite minimale (perte de la retenue). C'est à dire que "127 + 1 = -128" si on travaille sur une variable de type "char signé".  Il est possible de forcer un entier à être signé ou non-signé en rajoutant le mot clef "signed" ou "unsigned" avant son type (char, int, short int, long int). Une variable est signée par défaut donc le mot clef "signed" est inutile.

• Les réels

Ils respectent les règles de codage IBM des réels utilisant un bit pour le signe, "x" bits pour la mantisse et "y" pour l'exposant. Ils sont de deux types standard et un troisième non-standard :

• float : réel en virgule flottante codé sur 4 octets. Sa plage de valeur est de :

[+/-]701 411 x 10³⁸     à          [+/-]701 411 x 10³⁸

• double : réel en virgule flottante codé sur 8 octets. Sa plage de valeur est de :

 [+/-]1.0 x 10³⁰⁷           à          [+/-]1.0 x 10³⁰⁷

• long double :Réel en virgule flottante codé sur 12 octets. Sa plage de valeur est de :

 [+/-]3.4 x 10-⁴⁹³²        à          [+/-]1.1 x 10⁴⁹³². Mais ne faisant pas partie de la norme ANSI, il est souvent transformé en "double" par les compilateurs normalisés.

• Les booléens

Il n'existe pas en langage C de type booléen. Mais la valeur zéro est considérée par le langage Comme "faux" et toute autre valeur différente de zéro est considérée comme "vrai".

Exemple

#include <stdio.h>

unsigned char mask;

long          val;

main()

{

  unsigned int indice;

  float        x;

  double       y;

  char         c;

        ...

  return;

}

double f(double x)

{

  unsigned short taille;

  int            i;

  unsigned long  temps;

  double         y;

       ...

  return y;

}

• les fonctions d’entrée-sortie (affichage - La saisie)

L'affichage d'une valeur (variable ou constante) se fait en utilisant la fonction "printf( )" qui signifie "print formating"

Cette fonction s'utilise de la manière suivante :

®- Premier argument et le plus complexe : Message à afficher. Ce message, encadré par des " (double guillemets) constitue en fait tout le texte que le programmeur désire afficher. A chaque position du texte où il désire que soit reporté une variable ou une valeur d'expression, il doit l'indiquer en positionnant un signe "%" (pour cent) suivi d'un caractère indiquant la manière dont il désire afficher ladite valeur.

®- Autres arguments : Expressions et variables dont on désire afficher la valeur. Exemple :

main()

{

int a=5;

int b=6;

printf("Le résultat de %d ajouté à %d plus 1 est %d", a, b, a + b + 1);

}

La saisie d'une variable se fait en utilisant la fonction "scan( )" qui signifie "scan formating" Cette fonction s'utilise de la manière suivante :

®- Premier argument et le plus complexe : Masque de saisie. Ce masque, encadré par des " (double guillemets) constitue en fait tout ce que devra taper l'utilisateur quand il saisira ses variables. A chaque position du texte où le programmeur désire que soit reporté une variable à saisir, il doit l'indiquer en positionnant un caractère "%" (pour cent) suivi d'un caractère indiquant la manière dont il désire que soit saisie ladite valeur. Bien souvent, il n'y a aucun masque de saisie car c'est très contraignant.

®- Autres arguments : Variables à saisir, chacune précédée du caractère "&" Exemple :

main()

{

int jj;

int mm; int aa;

printf("Saisissez une date sous la forme jj/mm/aa :\n");

scanf("%d/%d/%d", &jj, &mm, &aa);

}

• Les constantes

Les constantes permettent de symboliser les valeurs numériques et alphabétiques de la programmation courante. Il peut paraître trivial d'en parler tellement on y est habitué mais cela est utile en langage C car il existe plusieurs formats de notation.

• constantes numériques en base 10 : on les note de la même façon que dans la vie courante. Ex :

5 (cinq) ; -12 (moins douze) ; 17 (dix-sept) ; -45 (moins quarante cinq) ; etc.

• constantes numériques en base 8 : on les note en les faisant toutes commencer par le chiffre "0". Ex :

05 (cinq) ; -012 (moins dix) ; 017 (quinze) ; -045 (moins trente-sept) ; etc.

• constantes numériques en base 16 : on les note en les faisant toutes commencer par les caractères "Ox" ou "0X". Ex : ox5 (cinq) ; -0x12 (moins dix-huit) ; 0x17 (vingt-trois) ; -0x45 (moins soixante-neuf) ; etc.

Remarque : il est possible de demander explicitement le codage des constantes précédemment citées sur un format "long" en les faisant suivre de la lettre "l" ou "L". Ex : 5L (nombre "cinq" codé sur 4 octets).

• constantes ascii : on les notes en les encadrant du caractère ' ' (guillemet simple ou accent aigu). Comme il s'agit d'un code ascii, le langage les remplacera par leur valeur prise dans la table des codes ascii : Ex : 'a' (quatre-vingt dix sept) ; 'A' (soixante-cinq) ; '5' (cinquante-trois) ; etc.
• constantes code ascii : permettent de coder une valeur ascii ne correspondant à aucun caractère imprimable. On utilise alors un backslash "\" suivi de la valeur ascii convertie en base 8 sur trois chiffres (en complétant avec des zéros si c'est nécessaire) ; ou bien la valeur ascii convertie en base 16 et précédé du caractère "x" ; le tout encadré des caractères "" (guillemet simple ou accent aigu). Ex : '\141 ' (quatre-vingt dix sept ; code ascii de "a"), '\x35' (cinquante-trois ; code ascii de "5") ; etc.
• constantes en virgule flottante

• notation anglo-saxonne : un nombre avec un "." (point) séparant la partie entière de la partie fractionnelle.

Ex : 3.1416     12.43        -0.38          .38       47.       .27

• notation scientifique : un nombre avec un "e" ou un "E" indiquant l'exposant du facteur "10".

Ex : 3e18 (3 x 10¹⁸).

Remarque : toutes les constantes en virgule flottantes sont codées en format "double". Il est cependant possible de demander explicitement le codage de ces constantes sur un format "float" en les faisant suivre de la lettre "f ou "F". Ex : 3.1416F (nombre "3.1416" codé sur 4 octets).

• constantes prédéfinies : il s'agit de constantes prédéfinies par le compilateur et ayant une fonction spéciale. On utilise la constante telle qu'elle encadrée des caractères "" (guillemet simple ou accent aigu).

• Les énumérations de constantes

Les énumérations sont des types définissant un ensemble de constantes qui portent un nom que l'on appelle énumérateur. Elles servent à rajouter du sens à de simples numéros, à définir des variables qui ne peuvent prendre leur valeur que dans un ensemble fini de valeurs possibles identifiées par un nom symbolique.

Syntaxe

enum [nom]

{

   énumérateur1,

   énumérateur2,

   énumérateur3,

       ...

   énumérateurn

};

Les constantes figurant dans les énumérations ont une valeur entière affectée de façon automatique par le compilateur en partant de 0 par défaut et avec une progression de 1. Les valeurs initiales peuvent être forcées lors de la définition.

enum couleurs {noir, bleu, vert, rouge, blanc,jaune};

enum couleurs

{

   noir = -1,

   bleu,

   vert,

   rouge = 5,

   blanc,

   jaune

};

Dans le 1^er exemple, les valeurs générées par le compilateur seront :

et dans le 2^e :

• Les opérateurs

Les opérateurs permettent de manipuler les variables et les constantes. Ils sont de trois type : ®-  opérateurs unaires : ils prennent en compte un seul élément ®-  opérateurs binaires : ils prennent en compte deux éléments ®-  opérateurs ternaires : ils prennent en compte trois éléments

• Opérateurs binaires

Ce sont les plus simples à appréhender. Les premiers peuvent s'appliquer à tout type de variable ou constante (entière ou à virgule flottante) :

• Egal (=) :             Affectation d'une valeur à une variable. Ex : a = 5    , k = j = 6
• Plus (+) : Addition de deux valeurs. Ex : 13 + 3
• Moins (-) : Soustraction de deux valeurs. Ex : 13 - 3
• Multiplié (*) : Multiplication de deux valeurs. Ex : 13 * 3
• Divisé (/) : Division de deux valeurs. Ex : 13 / 3
• Test d'égalité (==) :

Permet de vérifier l'égalité entre deux valeurs. Ex : a == b (si "a" est égal à "b" alors l'expression vaudra une valeur quelconque différente de "0" symbolisant le booléen "vrai" ; sinon l'expression vaudra "0"). Attention : Ecrire "=" en pensant "==" peut produire des incohérences graves dans le programme qui se compilera cependant sans erreur !

• Test de différence (!=) :

Permet de vérifier l'inégalité entre deux valeurs. Ex : a != b (si "a" est différent de "b" alors l'expression vaudra une valeur quelconque différente de "0" symbolisant le booléen "vrai" ; sinon l'expression vaudra "0"). Cet opérateur est l'opposé du "==".

• Tests d'inégalités diverses (>, <, >=, <=) :

Permet de vérifier les grandeurs relatives entre deux valeurs. Ex : a >= b (si "a" est supérieur ou égal à "b" alors l'expression vaudra une valeur quelconque différente de "0" symbolisant le booléen "vrai" ; sinon l'expression vaudra "0").

Les autres ne peuvent s'appliquer qu'aux valeurs (variables ou constantes) de type entière (char, short, long, int) :

• Modulo (%) :

Reste d'une division entière entre deux valeurs. Ex : 13 % 3

• "ET" logique (&&) :

Opération booléenne "ET" entre deux booléens. Ex : a && b (si "a" est "vrai" ET "b" est "vrai", alors l'expression vaudra une valeur quelconque différente de "0" symbolisant le booléen "vrai" ; sinon l'expression vaudra "0").

• "OU" logique (||) :

Opération booléenne "OU" entre deux booléens. Ex : a || b (si "a" est "vrai" de "0" OU "b" est "vrai", alors l'expression vaudra une valeur quelconque différente de "0" symbolisant le booléen "vrai" ; sinon l'expression vaudra "0").

Les suivants ne peuvent s'appliquer qu'aux valeurs (variables ou constantes) de type entière (char, short, long, int) et agiront individuellement sur chaque bit de la constante ou variable.

• "ET" bit à bit (&) :

Opération booléenne "ET" appliquée pour chaque bit des deux valeurs ; le nième bit de la première valeur étant comparé au nième bit de la seconde valeur. Ex : a & 5. Cette expression vaudra "5" si le premier et troisième bits de "a" sont à "1 " (masque).

• "OU" bit à bit (|) :

Opération booléenne "OU" appliquée pour chaque bit des deux valeurs ; le nième bit de la première valeur étant comparé au nième bit de la seconde valeur. Ex : a | 5. Cette expression donnera une valeur où les premier et troisième bits seront toujours à "1".

• "OU EXCLUSIF" bit à bit (^) :

Opération booléenne "OU EXCLUSIF" appliquée pour chaque bit des deux valeurs ; le nième bit de la première valeur étant comparé au nième bit de la seconde valeur. Ex : a ^ 5. Cet expression donnera une valeur où les premier et troisième bits seront à l'inverse de ceux de "a" (bascule).

• Décalage à droite (>>) :

Chaque bit de la valeur sera décalé vers la droite de "x" positions. Ex : 12 >> 3. Cela donne le même résultat que de diviser par 23.

• Décalage à gauche (<<) :

Chaque bit d'une valeur sera décalé vers la gauche de "x" positions. Ex : 12 << 4. Cela donne le même résultat que de multiplier par 24.

• Opérateurs d'opération avec affectation

Chaque opérateur binaire précédemment décrit peut être associé à l'opérateur "=" d'affectation. Cela permet de raccourcir une expression du style "a = a + x" par l'expression "a+=x" (sans espace entre le "+" et le "=").

• Opérateurs unaires

Une fois que l'on a compris les opérateurs binaires, les opérateurs unaires viennent plus facilement. Les premiers peuvent s'appliquer à tout type de variable ou constante (entière ou à virgule flottante) :

• Moins unaire (-) : Fait passer en négatif un nombre positif et inversement. Ex : -5
• Plus unaire (+) : Juste pour assurer la cohérence avec la vie réelle.Ex : +5
• Négation logique ( !) : Inverse les booléens "vrai" et "faux". Ex : !5
• Taille de (sizeof) : Renvoie la taille en octet de la valeur ou du type demandé. Ex : sizeof(char)

Le suivant ne peut s'appliquer qu'aux valeurs (variables ou constantes) de type entière (char, short, long, int) et agira individuellement sur chaque bit de la constante ou variable.

• "NOT bit à bit" (~) : Opération booléenne "NOT" appliquée à chaque bit de la valeur.. Ex : ~a. Cet expression donnera une valeur où tous les bits seront à l'inverse de ceux de "a".

Les quatre derniers ne s'appliquent qu'aux variables de type entière (char, short, long, int). Pour chaque exemple, nous prendrons une variable "i" initialement affectée avec "5".

• Pré-incrémentation (++ placé avant la variable) : Ex : ++i ("i" commence par s'incrémenter et passe à "6". Ensuite, l'expression renvoie la valeur finale de "i" ; soit "6").
• Post-incrémentation (++ placé après la variable) : Ex : i++ (l'expression renvoie d'abord la valeur initiale de "i" ; soit "5". Ensuite, "i" s'incrémente et passe à "6").
• Pré-décrémentation (-- placé avant la variable) : Ex : --i ("i" se commence par se décrémenter et passe à "4". Ensuite, l'expression renvoie la valeur finale de "i" ; soit "4").
• Post-décrémentation (-- placé après la variable) : Ex : i-- (l'expression renvoie d'abord la valeur initiale de "i" ; soit "5". Ensuite, "i" se décrémente et passe à "4").
  • Opérateurs ternaire

Il n'y en a qu'un seul qui peut s'appliquer à tout type de valeur

• vrai…alors…sinon ( ? :) : Ex : x ?y :z (si "x" est différent de "0" donc "vrai" ; alors l'expression complète vaut "y" sinon elle vaut "z").
  • Valeur et renvoi d'instruction

Toute instruction renvoie une valeur. Exemple, l'instruction "5;" renvoie une valeur qui est… "5". Il est possible, pour ne pas la perdre, de récupérer cette valeur par l'opérateur d'affectation "=" dans l'instruction "a=5;". Mais cette dernière instruction renvoie aussi une valeur qui est… "5". Il est alors encore possible de la récupérer par un nouvel opérateur d'affectation "=" dans l'instruction "b=a=5" ; etc. Il est ainsi possible de récupérer la valeur de chaque instruction écrite. Ex : a=(b == 2) (récupère dans "a" le booléen "vrai" ou "faux" résultant de la comparaison entre "b" et "2").

• Opérateur de concaténation

Celui-ci ne s'applique qu'aux instructions

• Concaténation d'instruction (,) : Permet de mettre plusieurs instructions à suivre et de ne prendre que la valeur de la dernière. Ex : int a,b,c=5 (déclare trois variables "a", "b" et "c" de type "int" et affecte "5" à "c").
  • Exercices

Calculez les résultats des expressions suivantes :

4. Les instructions de contrôle

Dans un programme, les instructions sont exécutées séquentiellement, c'est-à-dire dans l'ordre où elles apparaissent Or la puissance et le "comportement intelligent" d'un programme proviennent essentiellement :

• de la possibilité d'effectuer des "choix", de se comporter différemment suivant les "circonstances" (celles-ci pouvant être, par exemple, une réponse de l'utilisateur, un résultat de calcul...),
• de la possibilité d'effectuer des "boucles", autrement dit de répéter plusieurs fois un ensemble donné d'instructions.

Ces possibilités sont offertes par des instructions, nommées "instructions de contrôle", permettant de réaliser ces choix ou ces boucles.

• des choix : instructions if...else et switch,
• des boucles : instructions do...while, while et for.

• l’instruction if...else

Cette instruction permet une exécution conditionnelle d’une partie du code.

• Syntaxe de l'instruction if

Le mot else et l'instruction qu'il introduit sont facultatifs, de sorte que cette instruction présente deux formes.

Avec :

expression : expression quelconque

instruction__1  et instruction_2 : instructions quelconques, c'est-à-dire :

• simple (terminée par un point virgule),
• bloc,
• instruction structurée.

• exemples

L'expression conditionnant le choix est quelconque. La richesse de la notion d'express; en C fait que celle-ci peut elle-même réaliser certaines actions. Ainsi :

if ( ++i < limite)    printf ("OK") ;

est équivalent à :

i = i + 1 ;

if ( i < limite )    printf ("OK") ;

Par ailleurs :   

if ( i++ < limite )

est équivalent à :

i = i + 1 ;

if (  i-1 < limite )      

De même :

if { ( c=getchar() ) != '\n' )   

peut remplacer :

c = getchar() ;

if ( c != '\n' )

• Exercices d'application:

1. Ecrire le programme qui permet de lire deux nombres réel x et y et de les afficher dans l'ordre croissant.
2. Ecrire un programme qui fait la même chose qu'au précédent pour trois nombres x, y et z.
3. Ecrire un programme qui lie un caractère et vérifie s'il s'agit du caractère de tabulation ou retour à la ligne.
4. Ecrire un programme qui permet de lire un nombre et indique s'il est positif, nul ou négatif.

• Cas d'imbrication des instructions if

Nous avons déjà mentionné que les instructions figurant dans chaque partie du choix d'une instruction pouvaient être absolument quelconques. En particulier, elles peuvent, à leur tour, renfermer d'autres instructions if. Or, compte tenu de ce que cette instruction peut comporter ou ne pas comporter de else, il existe certaines situations où une ambiguïté apparaît C'est le cas dans cet exemple :

if (a<=b)    if (b<=c)   printf ("ordonné") ;

else printf ("non ordonné") ;

est-il interprété comme le suggère cette présentation ?

if (a<=b)   

if (b<=c) printf ("ordonné") ;

else   printf ("non ordonné") ;

ou bien comme le suggère celle-ci ?

if (a<=b)   

if (b<=c) printf ("ordonné") ;

else printf ("non ordonné") ;

La première interprétation conduirait à afficher "non ordonné" lorsque la condition a<=b est fausse, tandis que la seconde n'afficherait rien dans ce cas.

La règle adoptée par le langage C pour lever une telle ambiguïté est la suivante :

Un else se rapporte toujours au dernier if rencontré auquel un else n'a pas encore été attribué.

Dans notre exemple, c'est la seconde présentation qui suggère le mieux ce qui se passe.

• Exemple de cas d'imbrication des instructions if:

soit à écrire un programme de facturation avec remise, qui doit lire le prix hors taxes et calcule le prix TTC correspondant (avec un taux de TVA constant de 18,6%), et qui établit ensuite une remise dont le taux dépend de la valeur ainsi obtenue, à savoir :

• 0 % pour un montant inférieur à 1 000 DH
• 1 % pour un montant supérieur ou égal à 1 000 DH et inférieur à 2 000 DH
• 3 % pour un montant supérieur ou égal à 2 000 DH et inférieur à 5 000 DH
• 5 % pour un montant supérieur ou égal à 5 000 DH Ce programme est accompagné de deux exemples d'exécution.

#include<stdio.h>

#define TAUX_TVA    18.6

Main()

{

double ht, ttc, net, tauxr, remise ;

printf("donnez le prix hors taxes : ") ;

scanf ("%lf", &ht) ;

ttc = ht * ( 1. + TAUX_TVA/100.) ;

if ( ttc < 1000.)                 tauxr  = 0 ;

else   if ( ttc < 2000 )   tauxr  = 1. ;

else   if ( ttc < 5000 )   tauxr = 3. ;

else                tauxr  =5. ;

remise = ttc * tauxr /100. ;

net = ttc - remise ;

printf ("prix ttc          = %10.2lf\n", ttc) ;

printf ("remise            = %10.2lf\n", remise) ;

printf ("net à payer = %10.2lf\n", net) ;

}

Exemple Nº1 d'exécution :

donnez le prix hors taxes : 500

prix ttc      593.00

remise         0.00

net à payer    593.00

Exemple Nº2 d'exécution :

donnez le prix hors taxes : 4000

prix ttc     4744.00

remise        142.32

net è payer   4601.68

• L'INSTRUCTION SWITCH

L'instruction switch regarde si la valeur d'une expression fait partie d'un certain ensemble de constantes entières et effectue les traitements associés à la valeur correspondante.

• Syntaxe:

Avec:

expression : expression entière quelconque,

expression-constante : expression constante d'un type entier quelconque (char est accepté car il sera converti en int),

suite_d'instructions : séquence d'instructions quelconques.

N.B. : les crochets ( [ et ] ) signifient que ce qu'ils renferment est facultatif.

Chaque cas possible est étiqueté par une ou plusieurs constantes entières. L’expression est évaluée. Si elle correspond à une expression-constante, l’exécution commence par les instructions associées à cette étiquette.

L’instruction break permet de sortir immédiatement du switch. En effet lorsque le traitement d’un cas est terminé, l’exécution continue par le cas suivant. Pour différencier les divers cas il est donc nécessaire de terminer chacun d’entre eux par l’instruction break.

• Exemples d'introduction de l'instruction switch

1. a) Premier exemple

Voyez ce premier exemple de programme accompagné de trois exemples d'exécution.

1. b) deuxième exemple

Notez bien que le rôle de l'instruction break est fondamental. Voyez, à titre d'exemple, ce que produirait ce même programme en l'absence d'instructions break :

1. c) l'étiquette "default"

II est possible d'utiliser le mot clé "default" comme étiquette à laquelle le programme se "branchera" dans le cas où aucune valeur satisfaisante n'aura été rencontrée auparavant En voici un exemple :

• Exercice d'application de switch.

• L'INSTRUCTION do... while

La première façon de réaliser une boucle (une itération) en C, à savoir l'instruction do... while.

• Syntaxe de l'instruction do... while

L’instruction est exécutée puis l’expression est évaluée. L'instruction do..while répète l'exécution de l'instruction qu'elle contient tant que la valeur de la condition exprimer dans (expression) est vraie.

• Exemple d'utilisation de l'instruction do..while

On ne sait pas a priori combien de fois une telle boucle sera répétée. Toutefois, de par sa nature même, elle est toujours parcourue au moins une fois. En effet, la condition qui régit cette boucle n'est examinée qu'à la fin de chaque.

• Exercice d'application de l'instruction "do..while"

1. Ecrire le programme qui permet à l'utilisateur la saisie d'une seule phrase, et calcul le nombre de caractères saisis, sachant que la fin de la phrase est marquée par un point.
2. Ecrire un programme qui calcul la somme de 10 nombres flottants.
3. Ecrire un programme donne la valeur maximale parmi 10 nombres flottants saisie en utilisant .while.

• L'INSTRUCTION while

la deuxième façon de réaliser une boucle conditionnelle, à savoir l'instruction while.

• Syntaxe de l'instruction while

L’expression est évaluée. Si sa valeur est VRAIE , l’instruction est alors exécutée. Puis l’ex­pression est a nouveau évaluée.

L'instruction while répète alors l'instruction qui la suit tant que la condition mentionnée dans (expression) est vraie. comme le ferait do... while. Par contre, cette fois, la condition de poursuite est examinée avant chaque parcours de la boucle et non après. Ainsi, contrairement à ce qui se passait avec do... while, une telle boucle peut très bien n'être parcourue aucune fois si la condition est fausse dès qu'on l'aborde.

• Exemple d'utilisation de l'instruction while

Ce programme permet de répéter la saisie de nombres entiers tant que leur somme est inférieure à 100.

• Exercice application de l'instruction "while"

1. Ecrire le programme qui permet à l'utilisateur la saisie d'une seule phrase, et calcul le nombre de caractères saisis, sachant que la fin de la phrase est marquée par un point.
2. Ecrire un programme qui calcul la somme de 10 nombres flottants.
3. Ecrire un programme qui donne la valeur maximale parmi 10 nombres flottants saisie par en utilisant while.
   • L'INSTRUCTION FOR

Etudions maintenant la dernière instruction permettant de réaliser des boucles, à savoir l'instruction for.

• Syntaxe de l'instruction for

    
L'expression d'initialisation: expr1 est évaluée une seule fois, au début de l'exécution de la boucle.

L'expression de test d'arrêt: expr2 est évaluée et testée avant chaque passage dans la boucle, si elle est VRAIE le "corps-de-boucle" est exécutée.

L'expression d'incrémentation: expr3 est évaluée après chaque passage.

N.B. : les crochets ( [ et ] ) signifient que ce qu'ils renferment est facultatif.