2 - Éléments de base

Le traitement de l’information

Catégorie d’information

Du point de vue de la programmation, on distingue trois catégories d’information :

  • Les données : les informations à traiter

  • Les résultats : les informations escomptées (traitées)

  • Informations intermédiaires : celles qui permettent d’obtenir des résultats à partir des données

Exemple : Calculer le prix à payer à partir du prix d’un article taxable.

  • Données : le prix de l’article avant taxes, les taux des taxes : TPS (5.0%) et TVQ (7.5%)

  • Résultats : le prix (avec taxes) à payer à la caisse

  • Information(s) intermédiaire(s) : la TPS, la TVQ et le total de ces deux taxes

Identification d’une information

Dans notre vie quotidienne, nos noms et prénoms nous permettent de nous identifier, de nous différencier d’une autre personne. C’est la même chose en programmation : un identificateur est un nom qui permet d’identifier une information.

Un identificateur est une suite de caractères formés par des lettres et/ou des chiffres et qui commence par une lettre. La plupart des compilateurs acceptent aussi le caractère “souligné” pour donner plus de lisibilité à un identificateur.

Exemples : tp1, intra, tauxTps, tauxTvq, prixTotal, TAUX_TPS,

Il est maintenant permis d’utiliser des caractères accentués à l’intérieur d’un identificateur mais on déconseille cette pratique.

Les identificateurs suivants sont invalides :

tp#1, tp 1 (les caractères # et espace ne sont pas permis)

1erTP (le premier caractère n’est pas une lettre)

Conseils pratiques :

  1. Un identificateur sert à nommer une information (une donnée, un résultat, un nom de programme, une tâche à réaliser, …). Il est préférable d’utiliser des identificateurs significatifs : taille plutôt que t, racine plutôt que r, prix plutôt que p, etc.

  2. Longueur maximale d’un identificateur :

Cette longueur change d’un langage à un autre, d’un compilateur à un autre et ce, dans le même langage.

On vous conseille d’utiliser des identificateurs significatifs de longueur raisonnable : taille est plus simple et plus court à taper que la_taille_de_la_personne_a_traiter

  1. Les compilateurs C font la différence entre les identificateurs écrits en majuscules ou en minuscules :

Exemple : TP1, tp1, Tp1, tP1 représentent les identificateurs différents.

  1. Identificateurs prédéfinis ou réservés qui sont reconnus par le compilateur : il faut les écrire correctement (souvent en lettres minuscules), par exemple :

int main(), int, float, const, …

  1. Erreurs fréquemment commises sur les identificateurs :

  • 1ertp Faux commence par un chiffre

  • tp#1 Faux “#” n’est ni une lettre, ni un chiffre

  • tp 1 Faux espace n’est ni une lettre, ni un chiffre

Type de l’information

numérique :

  • entier : int (exemple : -32, 0, 12345)

  • réel : float (exemple : -32.67, 0.0, 1.78)

caractère(s) :

  • un seul caractère : char (exemple : ‘P’, ‘F’)

  • ou une chaîne de caractère(s) : à voir plus tard …

logique de type entier :

  • une valeur non nulle vaut vrai

  • une valeur nulle vaut faux

Durant les deux premières semaines de cours, on travaille surtout avec les types entiers (int), réels (float) et caractères (char). Le type logique (booléen) sera abordé vers la troisième semaine. Les autres types seront présentés plus tard dans le cours.

Exemple 1

Écrire les déclarations des variables suivantes :

  • sexe : une variable de type caractère (‘f’ pour féminin, ’m’ pour masculin)

  • taille et poids : deux variables de type réel

  • age : une variable de type entier

Solution

char  sexe;
float taille, poids;
int   age;

Exemple 2

Écrire les déclarations des variables suivantes :

sexe et poste : deux variables de type caractère (‘f’ pour féminin, ’m’ pour masculin; ‘a’ pour analyste, ‘p’ pour programmeur, ‘o’ pour opérateur)

numero : numéro de l’employé (un entier, exemple : 5478)

anciennete : le nombre d’années d’ancienneté (un entier)

Salaire hebdomadaire : un réel

Solution

char  sexe, poste;
float salHebdo;
int   numero, anciennete;

Exercice (sans solution)

Écrire les déclarations des variables représentant les informations suivantes d’un étudiant du cours IFT 1810 :

Son groupe, son numéro d’inscription, sa note du premier travail pratique, son statut social (célibataire, marié, séparé, divorcé, veuf).

Nature de l’information

Les constantes

On distingue deux catégories de constantes :

  • Les constantes éternelles : 2, 17.3, 3.14159 (PI), …

  • Les valeurs inchangées d’un problème à traiter : pour notre cours, les barèmes sont les mêmes pour tous les étudiants. Cependant, il est possible qu’on ait d’autres barèmes pour un autre cours ou qu’on change les barèmes d’un cours.

Quand doit-on déclarer les constantes? :

  • Pour généraliser le programme : les barèmes, les taux de taxes, les bonus, etc. S’il y a des changements dans les taux de taxes, par exemple la TPS qui passe de 7% à 5% et la TVQ qui passe de 7.5 % à 8.75 %. Il suffira alors de modifier les valeurs des constantes déclarées plutôt que d’aller fouiller dans tout le programme pour les trouver et les modifier.

  • Pour éviter des erreurs de frappe ou pour donner plus de précision dans les calculs (valeur de PI par exemple).

Comment peut-on déclarer les constantes? :

Méthode 1 : utiliser
#define  identificateur  valeur

Exemples :

#define TAUX_TPS 0.05
#define TAUX_TVQ 0.075

#define BAREME_INTRA 0.20

#define FEMININ 'F'
#define AGE_ADULTE 18

La directive #define fait remplacer le nom de la constante par sa valeur dans le programme. En langage C, on suggère d’utiliser les identificateurs des constantes en lettres majuscules.

Méthode 2 : utiliser

const type nom = valeur ….

Exemples :

const int   BORNE_ADULTE = 18;
const float TAUX_TPS = 0.06,
            TAUX_TVQ = 0.075,
            BAREME_INTRA = 0.20,
            PI = 3.14159;
const char  FEMININ = 'F';

Les variables

Une variable est une information dont la valeur peut changer (varier) au cours de l’exécution du programme.

type liste de variable(s);

Exemples :

int    age;
float  taille, poids, salHebdo;
char   sexe, poste;

Affectation

Un des moyens pour donner une valeur à une variable est d’affecter (déposer) à cette variable soit une constante, soit le résultat d’un calcul, soit la valeur d’une autre variable, etc . L’opérateur d’affectation est le symbole “=” en langage C :

variable = .....;

Exemples :

int age;
float taille1, taille2;

age = 18;
age = 3 * 12 - 5;
taille1 = (5 + 7 / 12.0) * 0.3048;
taille2 = taille1 + 0.17;

Une des caractéristiques spéciales en langage C est qu’on peut déclarer et initialiser en même temps la valeur de départ d’une variable :

int age = 17, anciennete, nbAdulte = 0;
float somTaille = 0.0, taille;

Commentaires

On utilise des commentaires pour décrire le but d’un programme, pour expliquer certaines déclarations ou quelques parties d’un programme.

Les lignes de commentaires sont placés entre les symboles /* et */.

Exemples :

/* But du programme : Ce programme permet de ....    */
int nbFem;   /* le nombre de femmes traitées */

/* Conversion de la taille en mètre : */
taille = (nbPieds + nbPouces / 12.0) * 0.3048;

Opérateurs de base

Opérateurs arithmétiques

Les opérateurs arithmétiques permettent de faire des calculs entre des valeurs numériques :

  • Entre des réels et/ou des entiers : +, -, * (la multiplication), / (la division entière ou réelle selon le type des opérandes)

  • Entre deux entiers : % (le reste d’une division)

Exemples :

3 * 5.4 vaut 16.2

10 / 4 vaut 2 (la division entre 2 entiers donne un entier comme résultat, on laisse tomber la partie des décimales)

10.0 / 4 ou 10 / 4.0 ou 10.0 / 4.0 vaut 2.5.

17 % 10 vaut 7 (dans 17 on a 1 fois 10, il reste 7)

25 % 4 vaut 1 (dans 25 on a 6 fois 4, il reste 1)

Notez que les opérateurs *, / et % ont priorité sur + et -. De plus, dans le cas d’une même priorité, on doit effectuer les calculs de gauche à droite pour les opérateurs arithmétiques :

17 / 5 * 4 + 2
------
   3
   -------
      12
      --------
         14

Pour IFT 1810, on utilise souvent l’opérateur % dans les travaux et aussi dans les questions d’examen.

Pour assurer une priorité absolue, on met des parenthèses :

17 / (5 * 4) + 2
     ------
       20
---------
    0
    ------------
         2

Dans le cours, on utilise assez souvent l’opérateur % qui donne le reste dans une division pour plusieurs exemples, notamment :

16 est un multiple de 4 car le reste dans la division de 16 par 4 vaut zéro : ainsi il est vrai d’écrire 16 % 4 == 0.

1237 % 10 vaut 7 (le dernier chiffre, celui des unités)

1996 % 100 vaut 96 (les 2 derniers chiffres)

Opérateurs relationnels (pour la comparaison)

Le résultat d’une comparaison est de type entier : 1 (vrai) ou 0 (faux)

< inférieur à

<= inférieur ou égal à

> supérieur à

>= supérieur ou égal à

== égale à (notez que le symbole “=” est utilisé pour l’affectation)

!= différent de

Exemples :

17 < 23 vaut 1

'c' != 'C' vaut 1

17 % 5 == 4 vaut 0 ( 17 % 5 donne 2, 2 == 4 est faux )

Opérateurs logiques

Relier deux conditions : && (et logique) , || (ou logique)

Pour obtenir le contraire d’une condition : ! (non logique)

A && B vaut vrai (1) <==> A et B sont “vrai simultanément”

A || B vaut vrai (1) <==> A ou B ou les deux sont “vrai”

Exemples

(25 > 36 && 8 > 5)  
 -------
 faux (0) et "n’importe quoi"
 ----------------------------
           faux (0)
(3 <= 3 && 4 >= 2.5)
 ------
 vrai (1)
           --------
           vrai (1)
        et
 ------------------
      vrai (1)

Écriture et lecture en mode conversationnel

En mode conversationnel (interactif), on écrit les informations à l’écran (afficher à l’écran) et on saisit les données tapées au clavier par l’usager du programme.

Affichage à l’écran avec printf
printf("format", liste d'informations à afficher);

où :

  1. printf désigne l’écriture (print : imprimer, ici dans le sens d’afficher, f vient du mot format (de présentation)).

  2. format désigne des messages à afficher tels quels et des codes formats pour afficher des informations de type différents :

%d pour un entier

%f pour un réel

%c pour un caractère

%s pour une chaîne de caractères (plus tard dans le cours)

etc.

Dans le format, on rencontre très souvent les caractères \n qui provoquent un changement de ligne (new line).

Dans les exemples d’affichage, on utilise le symbole ^ (chapeau) pour représenter une espace (un blanc).

Exemples

Avec les déclarations et les affectations suivantes :

int age, nbCafe;
float taille;
char  sexe;

age = 23;
nbCafe = 3;
taille = 1.72;
sexe = 'M';
  1. printf("%d%d", age, nbCafe);

fait afficher : 233 (les 2 entiers sont collés)

  1. printf("%3d%4d", age, nbCafe);

fait afficher : ^23^^^3

3 espaces pour afficher l’entier âge (valeur 23)

4 espaces pour afficher l’entier nbCafe (valeur 3)

  1. printf("age = %3d, Nombre de tasses de cafe = %4d", age, nbCafe);

fait afficher :

age = ^23, Nombre de tasses de cafe = ^^^3
printf("age                      : %4d\n", age);

printf("Nombre de tasses de cafe : %4d\n", nbCafe);`

fait afficher :

age                      : ^^23
Nombre de tasses de cafe : ^^^3
printf("%f%f%6.3f%8.2f", taille, taille, taille, taille);`

fait afficher :

1.7200001.720000^1.720^^^^1.72

(par défaut, on a 6 chiffres après le point décimal).

Comme auparavant, on encourage la manière suivante :

printf("La taille de la personne : %5.2f metre\n", taille);

qui fait afficher :

La taille de la personne : ^1.72 metre

  1. printf("%c%3c%5c\n", sexe, sexe, sexe);

fait afficher : M^^M^^^^M

  1. En résumé, la suite des instructions suivantes :
printf("Les informations de la personne :\n\n");
printf("  - sexe     : %5c\n", sexe);
printf("  - age      : %5d ans\n", age);
printf("  - taille   : %5.2f metre\n", taille);
printf("  - Nb. cafe : %5d tasse(s)\n", nbCafe);

fait afficher :

Les informations de la personne :

  • sexe : ^^^^M

  • age : ^^^23 ans

  • taille : ^1.72 metre

  • Nb. cafe : ^^^^3 tasse(s)

Warning

Attention :

Voici comment on répartit une longue instruction qui contient un long message sur plus d’une ligne :

printf("L'employé est un analyste qui gagne %6.2f $ par "
       "semaine et reçoit un bonus de %5.1f $\n", salHebdo, bonus);

Nous reviendrons plus tard sur les autres détails de printf.

Lecture de données avec scanf

scanf("codes format", liste des adresses des variables à lire);

Nous utilisons l’opérateur & (adresse de) qui sera présenté en détail au prochain chapitre. Pour les deux premières semaines de cours, on interprète une saisie de donnée :

printf("Entrez l'age de la personne : ");
scanf("%d", &age);

Comme ceci :

  • Lire un entier tapé au clavier par l’usager;

  • Déposer cet entier à l’adresse de la variable age.

et on essaie de comprendre avec le simple exemple suivant :

un facteur peut livrer une lettre chez-nous s’il connaît notre adresse;

(un compilateur peut déposer une valeur lue dans une variable s’il connaît son adresse).

Exemples

  1. Lecture d’un seul entier ou d’un seul réel
printf("Entrez l'age de la personne : ");
scanf ("%d", &age);

On lit la valeur et on la dépose à l’adresse de la variable âge (à son emplacement en mémoire).

Après le message d’incitation “Entrez l’age de la personne : “, l’usager peut taper l’âge (avec ou sans espaces) suivi de la touche <Entrée> :

Entrez l'age de la personne : ^^^^^23
age vaut 23

Entrez l'age de la personne : 23
age vaut aussi 23
printf("Entrez la taille de la personne : ");
scanf("%f", &taille);

Après le message “Entrez la taille de la personne : “, si l’usager tape ^^^1.65 suivi de la touche <Entrée>, taille vaut 1.65

  1. Lecture des valeurs numériques
printf("Entrez l'age et la taille de la personne : ");
scanf("%d%f", &age, &taille);

Après le message “Entrez l’age et la taille de la personne : “, il suffit de taper 2 valeurs séparées par au moins une espace suivie de la touche <Entrée> :

Entrez l’age et la taille de la personne : 41^1.70

age vaut 41 ans et taille vaut 1.70 mètre.

  1. Lecture d’un caractère
printf("Entrez f, F, m ou M pour le sexe :");
scanf("%c", &sexe);

Après le message “Entrez f, F, m ou M pour le sexe :”, on tape tout de suite le caractère suivi de la touche <Entrée> :

Entrez f, F, m ou M pour le sexe :f
sexe vaut 'f'

Par contre :

Entrez f, F, m ou M pour le sexe :^f
sexe vaut ' ' (caractère espace)

On utilise souvent getchar() pour la lecture d’un seul caractère :

printf("Entrez f, F, m ou M pour le sexe :");
sexe = getchar(); /* avec écho (on voit le caractère tapé) */
  1. Lecture de plusieurs informations
printf("Entrez sexe, age et taille :");
scanf("%c%d%f", &sexe, &age, &taille);
Avec : Entrez sexe, age et taille :m^19^1.68
sexe vaut 'm', age vaut 19 et taille vaut 1.68

Instructions de base en langage C

Instruction simple

Une seule instruction qui réalise un traitement : une lecture, une écriture, une affectation, etc . On doit terminer une instruction simple par le point virgule ;.

Exemples

printf("Entrez le rayon d'un cercle :");
scanf("%f", &rayon);

surface = 3.14159 * rayon * rayon;

Instruction composée

  • Un bloc d’instructions qui sont séparées les unes des autres (très souvent) par un point virgule et qui sont délimitées par { (début) et } (fin)

  • On utilise souvent une instruction composée quand on décide de faire deux ou plusieurs actions sous une condition (vrai ou faux).

Exemple

if (sexe == 'F' || sexe == 'f'){
    printf("C'est une femme");
    nbFemmes = nbFemmes + 1 ;
} else {
    printf("C'est un homme");
    taille = (nbPieds + nbPouces / 12.0) * 0.3048;
    nbHommes = nbHommes + 1;
}

Instructions de sélection (de décision)

La sélection simple

  1. Syntaxe
if (condition)
  instruction 1
else
  instruction 2

ou

if (condition)
  instruction 1
  1. Fonctionnement

Si la condition vaut vrai (c’est-à-dire, en langage C, sa valeur est non nulle), on exécute l’instruction 1. Dans le cas contraire (sinon), et si la clause else est présente, on effectue l’instruction 2.

  1. Remarques

  • La clause else est facultative (optionnelle)

  • La condition (l’expression) doit être entre parenthèses

  • Le then (alors) n’existe pas comme en PASCAL ou en Visual Basic

  • L’instruction sous le if (instruction 1) et l’instruction sous le else (instruction 2) peuvent être simples (une seule action), structurées (une autre instruction de contrôle) ou composées (bloc d’instructions). Si c’est une instruction simple, il faut la terminer par le point virgule (même si elle se trouve devant la clause else).

  1. Exemples

a)

if (age <= 11)
   printf("C'est un enfant\n");
else
   printf("C'est un adolescent ou un adulte\n");

b)

if (sexe == 'f' || sexe == 'F')
  nbFemmes = nbFemmes + 1;

c)

if (sexe == 'm' || sexe == 'M'){
  nbHommes = nbHommes + 1;
  printf("sexe : Masculin\n");
} else {
  nbFemmes = nbFemmes + 1;
  printf("sexe : Feminin\n");
    somTaille = somTaille + taille;
}

d) Cas de if imbriqué (if à l’intérieur d’un autre if) :

if (poste == 'A'){
    bonus = 123.45;
    printf("analyste\n");
} else if (poste == 'P'){
    nbProgrammeur = nbProgrammeur + 1;
    printf("programmeur\n");
    totSalProg = totSalProg + salHebdo;
} else
    printf("Autre poste\n");

e) Exercices

Soient les déclarations suivantes :

int  age;
char sexe;

Écrire une instruction permettant de vérifier si une personne est une adolescente (sexe : féminin, âge : entre 12 et 17).

Solution :

if ((sexe == 'f' || sexe == 'F') &&
    (age >= 12 && age <= 17))
    printf("C'est une adolescente");

Écrire une instruction permettant de vérifier si une personne est un homme dont l’âge dépasse 60 ans.

Solution :

if ((sexe == 'm' || sexe == 'M') && age > 60)
    printf("C'est un homme de plus de 60 ans");

Écrire une instruction permettant de vérifier si une personne est un enfant. Dans ce cas, on affiche des messages du genre :

Enfant de 7 ans

sexe : masculin

Dans le cas contraire, on affiche un message pertinent.

Solution :

if (age <= 11){
   printf("Enfant de %d ans\n", age);
   if (sexe == 'm' || sexe = 'M')
      printf("sexe : masculin\n");
   else
      printf("sexe : feminin\n");
} else
   printf("Ce n'est pas un enfant\n");

Écrire des instructions permettant d’afficher des messages du genre :

Adulte de sexe masculin ou

Enfant de sexe feminin ou

Adolescent de sexe masculin

Solution :

if (age < 12)
   printf("Enfant ");
else if (age < 18)
   printf("Adolescent ");
else 
   printf("Adulte ");

if (sexe == 'f' || sexe == 'F')
   printf("de sexe feminin");
else
   printf("de sexe masculin");

Exercice

Écrire un bloc d’instructions permettant de saisir le rang d’une journée de la semaine (dimanche est représenté par 1, lundi par 2, …) et d’afficher un message du genre :

On travaille dur! (du lundi au jeudi)

La fin de semaine s’en vient (le vendredi)

Youpi! C’est la fin de semaine! (le samedi et le dimanche)

Rang invalide! (pour un rang imprévu)

La donnée du problème est la variable rang (de type entier) tandis que le résultat est un message qui dépend de la valeur de rang (voir ci-dessus)

Cheminement :

   Lire rang

   Si (rang >= 2 et rang <= 5) Alors
      Afficher "On travaille dur!
   Sinon
      Si (rang == 6) Alors
          Afficher "La fin semaine s'en vient"
      Sinon
         Si (rang == 1 ou rang == 7) Alors
            Afficher "Youpi! C'est la fin semaine!"
         Sinon
            Afficher "Rang invalide!"

Le code en langage C

/*  Auteurs : Charbonneau Julien, Section C et 
               Dube Renée, Section D

     Date : 13 septembre 2007 pour le cours IFT 1810

     But : Ce programme permet de saisir le rang d'une journée et
           d'afficher un message pertinent selon la valeur du rang
           saisi
*/

#include <stdio.h>

int main() {
   int rang; /* le rang d'une journée (1 : dimanche, 2 : lundi, ...,        
                7 : samedi)*/

   /* Saisir le rang */
   printf("Entrez le rang d'une journee (entre 1 et 7) : ");
   scanf("%d", &rang);



   /* afficher un message pertinent : */
   if (rang >= 2 && rang <= 5)             /* du lundi à jeudi */
      printf("On travaille tres fort!");
   else 
     if (rang == 6) /* vendredi */
      printf("La fin semaine s'en vient");
     else 
         if (rang == 1 || rang == 7) /* dimanche ou samedi */
            printf("Youpi! C'est la fin semaine!");
         else /* dans le sens autrement */
            printf("Rang invalide!");
   
   printf("\n\n");
   
   system("pause");
   
   return 0;
}

Exécution :

Entrez le rang d'une journee (entre 1 et 7) : 5
On travaille tres fort!

Appuyez sur une touche pour continuer...

La sélection multiple avec switch … :

  1. Syntaxe : cette instruction est semblable à Select Case … en Visual Basic.
switch (expression){
   case valeur1:
      instructions1;
      break;

   case valeur2:
      instructions2;
      break;
...

   case valeurn:
      instructionsn;
      break;

   default:
      instructionsn+1;
      break;
}

Le switch permet de construire une table de branchement à partir d’une expression. Il remplace avantageusement une suite de if imbriqués.

L’expression expression est évaluée, puis elle branche directement sur le bon cas case s’il est défini. Les valeurs valeur1, valeur2,… , valeurn, doivent être des valeurs de type entier ou de type caractère. Si le branchement est trouvé, les énoncés qui suivent le case seront exécutés. Le mot réservé break signale la fin de la série d’énoncés à exécuter pour un case particulier et force, du même coup, la fin de l’instruction switch. Si le résultat de l’expression ne correspond à aucun branchement, les instructions correspondant au branchement default, s’il existe, seront exécutées.

Il est possible d’accepter plus d’une valeur pour une même série d’instructions, sans réécrire ceux-ci. On écrit tout simplement les autres case à la suite du premier, comme ceci :

case valeur1:
case valeur2: instructions;
    break;

Ici, les instructions sont exécutées lorsque l’expression est égale à valeur1 ou à valeur2.

Exemple :

char  poste;
float bonus;
.....
switch (toupper(poste)){ /* suivant que le poste vaut  */
   case 'A': bonus = 235.50;
             printf("analyste\n");
             break;
   case 'O':
   case 'P': bonus = 175.00;
             break;
   case 'S': bonus = 150.75;
             printf("Secretaire\n");
             break;
   default:  printf("poste errone\n");
}
  1. Fonctionnement

L’expression suivant switch est évaluée; sa valeur vaut x, par exemple;

On cherche dans le bloc s’il existe une étiquette de la forme case x où x est la valeur de l’expression :

  • Si oui :

On exécute les instructions à partir de ce cas jusqu’à ce qu’on rencontre :

  1. Un break (on sort du bloc et on termine le switch)

  2. La fin du switch

Après avoir exécuté ces instructions, on quitte le switch.

  • Si non :

Si la clause default (qui signifie “autrement”) est présente, on effectue la suite d’instructions sous cette clause et on quitte le switch.

Si la clause default n’existe pas, on termine le switch.

  1. Remarques

  • L’expression dans switch(expression) est une expression entière. Le cas d’un caractère est accepté car le compilateur convertit un caractère en entier (son ordre).

  • La suite d’instructions peut être vide : aucune instruction.

  • Pour sortir de switch, après avoir effectué des instructions voulues, ne pas oublier de terminer avec un break. Si oublié, toutes les suites d’intructions suivantes seront exécutées jusqu’à la rencontre d’un break ou la fin de switch.

  • La clause default est facultative.

  1. Exemples

Exemple 1 (deuxième solution de l’exercice situé aux pages 37)

int rang;
printf("Entrez le rang d'une journée (entre 1 et 7) :");
scanf("%d", &rang);

switch (rang){
            /* du lundi à jeudi : */
    case 2:
    case 3:
    case 4:
    case 5: printf("On travaille tres fort!\n");
            break;
                     /* le vendredi : */
             case 6: printf("La fin de semaine s'en vient\n");
                     break ;
                     /* samedi ou dimanche : */
             case 7:
             case 1: printf("Youpi! C'est la fin de semaine\n");
                     break ;
                      /* autrement : */
             default: printf("Rang invalide!\n");
         }

Exemple 2

Pour satisfaire son personnel, la société “LA GÉNÉREUSE” décide d’accorder une bonification de 500 $ aux analystes, 400 $ aux programmeurs et opérateurs et 375 $ aux secrétaires.

Écrire un programme en langage C permettant :

  • D’obtenir le salaire hebdomadaire

  • D’obtenir le poste de travail, soit un seul caractère :

    • ‘A’ ou ‘a’ pour analyste

    • ‘P’ ou ‘p’ pour programmeur

    • ‘O’ ou ‘o’ pour opérateur

    • ‘S’ ou ’s’ pour secrétaire

  • De calculer le bonus à accorder dépendemment du poste

  • D’afficher à l’écran un message du genre :

C’est un opérateur qui gagne 567.89 $ par semaine et reçoit 400.00 $ de bonus.

Solution :

#include <stdio.h>
#include <ctype.h>  /* pour la conversion en majuscule : 
                       toupper(...) : to (en) upper (majus)*/

void main()
{
   char  poste;
   float bonus, salHebdo;

   #define BONUS_A  500.00  /* bonus pour les analystes     */
   #define BONUS_OP 400.00  /* bonus pour les programmeurs  */
                            /* ou les opérateurs            */
   #define BONUS_S  375.00  /* bonus pour les secrétaires   */

   printf("Entrez le poste et le salaire hebdomadaire : ");
   scanf ("%c%f", &poste, &salHebdo);

   poste = toupper(poste);
   printf("C'est un ");

   switch (poste){
     case 'A': bonus = BONUS_A;
               printf("analyste ");
               break;
     case 'O':
     case 'P': bonus = BONUS_OP;
               if (poste == 'O')
                  printf("operateur ");
               else
                  printf("programmeur ");
               break;
     case 'S': bonus = BONUS_S;
               printf("secretaire ");
   }

   printf("qui gagne %6.2f $ par semaine et reçoit %6.2f $ "
          "de bonus \n", salHebdo, bonus);
}
  1. Exercices

Numéro 1 (niveau simple)

Écrire un programme permettant de saisir un caractère représentant le code d’une figure :

  • ‘c’ ou ‘C’ pour un cercle

  • ‘r’ ou ‘R’ pour un rectangle

  • ‘k’ ou ‘K’ pour un carré

Dans le cas d’un cercle, le programme saisit son rayon. Il effectue les calculs et affiche les résultats à l’écran :

  • Le périmètre (2 x PI x rayon) et

  • La surface (PI x (rayon au carré))

Dans le cas d’un rectangle, le programme saisit la longueur et la largueur. Il effectue les calculs et affiche les résultats à l’écran :

  • Le périmètre (2 x (longueur + largueur))

  • La surface (longueur x largueur)

Dans le cas d’un carré, le programme saisit le côté. Il effectue les calculs et affiche les résultats à l’écran :

  • Le périmètre (4 x côté)

  • La surface (côté au carré)

Si le code est imprévu, nous affichons un message pertinent.

Numéro 2 (bon exercice de révision)

Écrire un programme en langage C permettant de saisir le rang d’un mois (1 pour le mois janvier, 2 pour février, …, 12 pour décembre) et d’afficher le nombre de jours du mois saisi. Dans le cas du mois de février, on doit saisir aussi l’année (exemple : 1996) et déterminer si l’année est bissextile (29 jours au mois de février) ou non.

Notez que :

  • Janvier, mars, mai, juillet, août, octobre, décembre ont 31 jours.

  • Avril, juin, septembre, novembre ont 30 jours.

  • Un algorithme qui peut déterminer si une année est bissextile, se présente comme suit :

Soit An les deux derniers chiffres d’une année (An vaut 99 pour Annee valant 1999 ==> An = Annee % 100). Soit Siecle les deux premiers chiffres (Siecle vaut 19 pour Annee valant 1999 ==> Siecle = Annee / 100).

Annee est bissextile (29 jours en février) <===> (An est différent de zéro ET An est un multiple de 4) OU (An est zéro ET Siecle est un multiple de 4)

Exemples : Annee = 1996 ==> An = 96 et Siecle = 19

La condition : 96 est différent de zéro et 96 est un multiple de 4 est vérifiée. L’année 1996 est bissextile.

Annee = 2000 ==> An = 0 et Siecle = 20 La condition : An est zéro et 20 est un multiple de 4 est vérifiée. L’année 2000 sera bissextile.

#include <stdio.h>
 /*********************************************************************
  *  Auteurs : Beauchemin Isabelle, Section C et                      * 
  *            Tremblay Michel, Section D                             *
  *                                                                   *
  *  Date : 13 septembre 2009 pour le cours IFT 1810                  *
  *                                                                   *
  *  But : Ce programme permet de saisir le rang d'un mois et         *
  *        d'afficher le nombre de jours du mois. Dans le cas du mois *
  *        de février, on saisit aussi l'année et détermine si        *
  *        le mois a 28 ou 29 jours au mois de février                *
  *********************************************************************/

int main()
{
   int rang;  /* le rang du mois */
   int annee, /* exemple 1996 */
   an,        /* 2 derniers chiffres de l'année, exemple 96 */
   siecle;    /* 2 premiers chiffres de l'année, exemple 19 */

   /* saisir le rang */
   printf("Entrez le rang d'un mois (entre 1 et 12) : ");
   scanf("%d", &rang);

   printf("\nSolution avec if ...... : \n");

   printf("Le mois de rang %d ", rang);

   if (rang == 1 || rang == 3  || rang == 5 || rang == 7 || 
                     rang == 8 || rang == 10 || rang == 12) 
      printf("a 31 jours ");
   else if (rang == 4 || rang == 6  || rang == 9 || rang == 11)
      printf("a 30 jours");
   else if (rang == 2){
      printf("est fevrier. On a besoin de l'annee\n");
      printf("Entrez l'annee (exemple 2001) : ");
      scanf("%d", &annee);

      an = annee % 100;
      siecle = annee / 100;

      if ((an != 0 && an % 4 == 0) ||
          (an == 0 && siecle % 4 == 0))
         printf("On a 29 jours en fevrier %d", annee);
      else
         printf("L'annee %d a un mois de fevrier de 28 jours", annee);

   } else
      printf("n'existe pas!");
   printf("\n\n");

   printf("\nSolution avec switch ...... : \n");

   switch (rang){
      case 1 :
      case 3 :
      case 5 :
      case 7 :
      case 8 :
      case 10:
      case 12: printf("31 jours\n");
               break;
      case 4 :
      case 6 :
      case 9 :
      case 11 : printf("30 jours\n");
                break;

      case 2 :  printf("On a besoin de l'annee\n");
                printf("Entrez l'annee (exemple 2001) : ");
                scanf("%d", &annee);

                an = annee % 100;
                siecle = annee / 100;

                if ((an != 0 && an % 4 == 0) ||
                    (an == 0 && siecle % 4 == 0))
                   printf("On a 29 jours en fevrier %d", annee);
                else
                   printf("L'annee %d a 1 mois de fevrier de 28 jours", 
                              annee);
                break;
      default : printf("Rang %d est invalide", rang);
   }
   printf("\n\n");
   
   system("pause");
   return 0; 
}

Exécution:

Entrez le rang d'un mois (entre 1 et 12) : 2

Solution avec if ...... :
Le mois de rang 2 est fevrier. On a besoin de l'annee
Entrez l'annee (exemple 2001) : 2007
L'annee 2007 a un mois de fevrier de 28 jours


Solution avec switch ...... :
On a besoin de l'annee
Entrez l'annee (exemple 2001) : 2008
On a 29 jours en fevrier 2008

Appuyez sur une touche pour continuer...

Écriture “raccourcie” en langage C

variable = variable operateur opérande;

peut aussi s’écrire ainsi : variable operateur= opérande;

Exemples :

somme = somme + taille; //===> somme += taille;
n = n / 10;             //===> n /= 10;
  • Incrémentation : nbFem = nbFem + 1;

peut aussi s’écrire ainsi: nbFem += 1; /* voir point précédent */

ou plus court encore : nbFem++;

  • Décrémentation : nbFem = nbFem - 1;

peut aussi s’écrire ainsi: nbFem -= 1; /* voir point précédent */

ou plus court encore : nbFem--;

  • D’autres utilisations des opérateurs “++” et “–” seront présentées dans le cours suivant (IFT 1166, suite de IFT 1810).

  • Déclaration et initialisation en même temps :

int   nbFem = 0, age, nbHom = 0;
float somTaille = 0.0, taille;
  • Affectation multiple :
nbFem = 0;
nbHom = 0;
Nb_Pers= 0;

peut aussi s’écrire ainsi:

nbFem = nbHom = Nb_Pers = 0;

Le type booléen (logique)

Une valeur de type booléen peut être VRAI ou FAUX.

La condition : 27 > 12 vaut VRAI tandis que 12 > 45 vaut FAUX.

En langage C, le type booléen n’existe pas.

Avec :

printf("%d", 27 > 12); le langage C affiche 1.
printf("%d", 12 > 45); le langage C affiche 0.

Ainsi, une condition qui est VRAI vaut un et une condition qui est FAUX vaut zéro.

Par contre, une valeur numérique non nulle est considérée comme VRAI.

Le bloc :

int age = 18;
if (age)  /* Si (age) <==> Si (age est non nul) */
printf("ABC");
else 
printf("XYZ");

affiche à l’écran ABC.

On utilise très souvent le type int pour programmer le type booléen.

char sexe;
int  valide;

printf("Entrez f ou m pour le sexe :");
sexe = toupper(getchar());

valide = (sexe == 'F') || (sexe == 'M');

if (!valide)  /* Si Non valide */
   printf("caractere imprevu pour le sexe ");
...

Introduction aux notions d’adresse

Une variable a un nom (son identificateur), un type et une valeur. Avec la déclaration suivante :

int age = 23;

age est le nom d’une variable de type entier dont la valeur est 23. Dépendant du type de la variable, le compilateur réserve un nombre d’octets (bytes) pour mémoriser l’information. L’opérateur sizeof (taille de …, nombre d’octets de …) permet de calculer le nombre d’octets nécessaires pour mémoriser une variable ou une information d’un type donné. Dans notre environnement Windows XP, et sous Microsoft Visual C++ :

  • sizeof(int) ou sizeof(age) vaut 4 (age est de type int)

  • sizeof(float) ou sizeof(taille) vaut 4 (taille est de type float)

  • sizeof(char) ou sizeof(sexe) vaut 1 (sexe est de type char)

Chaque octet a une adresse en mémoire :

Mémoire Mémoire

En langage C, on ajoute une caractéristique de plus à une variable : son adresse (son emplacement en mémoire) déterminée par l’opérateur & (adresse de). C’est l’adresse du premier octet du bloc d’octets qui mémorise la valeur de cette variable.

L’adresse d’une variable est déterminée souvent à la compilation de manière séquentielle.

Exemple d’illustration des adresses

Soit le programme suivant :

/* Fichier Adresse.C (introduction aux adresses)
Dans ce programme, on affiche une adresse avec le code format %u, "u" pour "unsigned integer" : entier sans signe (positif) : entre 0 et 65535. Ce format en valeur de décimale rend facile des explications (le format %p donne l'adresse en hexadécimal) 
 */

#include <stdio.h>

int          a = 5, b = 23;
float        x = 123.4;
char         d = 'V';
int          c = 100;
double       taille  = 1.72;

int main()
{
  printf("Nom            Type     Nb. octets  Adresse   Valeur\n");
  printf("------         -----    ----------  -------   ------\n");
  printf(" a             int           %d      %u   %d\n", sizeof(a), &a, a);
  printf(" b             int           %d      %u   %d\n", sizeof(b), &b, b);
  printf(" x             float         %d      %u   %6.2f\n",sizeof(x), &x, x);
  printf(" d             char          %d      %u   %c\n",sizeof(char), &d, d);
  printf(" c             int           %d      %u   %d\n", sizeof(int), &c, c);
  printf(" taille        double        %d      %u   %6.2f\n", sizeof(taille), &taille, taille);
  
  printf("\n\nL'operateur * (contenu de l'adresse) :\n");
  printf("Le contenu a l'adresse %u est %d\n", &b, *(&b));
  printf("Le contenu a l'adresse %u est %6.2f\n", &x, *(&x));
  
  printf("\n\n");
  system("pause");
  
  return 0;
}

Exécution :

             Nom            Type     Nb. octets  Adresse   Valeur
------         -----    ----------  -------   ------
 a             int           4      4202496   5
 b             int           4      4202500   23
 x             float         4      4202504   123.40
 d             char          1      4202508   V
 c             int           4      4202512   100
 taille        double        8      4202520     1.72


L'operateur * (contenu de l'adresse) :
Le contenu a l'adresse 4202500 est 23
Le contenu a l'adresse 4202504 est 123.40


Appuyez sur une touche pour continuer...

Schéma d’explication

La case d’un octet dispose d’une adresse en mémoire. Dépendant du type de la variable, le compilateur alloue un nombre de cases (dans notre environnement de travail : 4 cases pour un entier, 4 pour un réel, 1 pour un caractère, etc.).

Les valeurs sont codées en binaire. Pour une meilleure compréhension, on les représente ici comme des valeurs usuelles (entier, réel, caractère). Veuillez remarquer que le premier octet de chaque variable est un multiple de 4 (plus facile pour obtenir l’adresse d’une information car 4 fois 8 = 32 bits)

Mémoire2 Mémoire2

On voit aussi l’opérateur * dont :

*(adresse) <===> le contenu (la valeur) qui se trouve à cette adresse

Ainsi : *(&b) <==> le contenu à l’adresse 1245048 <==> 23 (valeur de b)

*(&x) <==> le contenu à l’adresse 1245044 <==> 123.40 (valeur de x)

Veuillez noter que ces informations ne sont pas à évaluer pour IFT 1810.

Elles vous permettent d’avoir une petite idée sur la notion de l’adresse et plus tard, dans certains autres cours, la notion de pointeur.

On revient maintenant à la lecture de données réalisée lors de la première semaine :

printf("Entrez la valeur de b :");
scanf("%d", &b);

On interprète scanf("%d", &b); comme suit :

Lire la valeur tapée et déposer cette valeur à l’adresse 1245048 (l’adresse de b) ===> b vaut la valeur saisie.

Exercices de révision

Exercice 1

Écrire les déclarations qui rendent valide les instructions suivantes :

printf("Entrez un poste de travail :");
poste = getchar();

analyste = poste == 'a' || poste == 'A';

programmeur = toupper(poste) == 'P';

Solution :

#include <ctype.h> /* pour appeler toupper to upper : en majuscule */
. . . 
char poste;

/* En langage C, on utilise souvent le type int (entier) pour remplacer
   le type booléen */
int analyste, programmeur;

Exercice 2

Que fait afficher la suite d’instructions ci-dessous?

int  age = 13;
switch (age){
   case  5: printf("5 ans ");
            break ;
   case  7:
   case 13:
   case  9: printf("7, 13 ou 9 ans ");
   default: printf("autres cas ");
}

Solution :

7, 13 ou 9 ans autres cas