CHAPITRE 2 : Éléments de base de la programmation

A) Le traitement de l'information

1) 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

2) 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)

Chapitre 2 : Éléments de base de la programmation 21

Préparé par Le Van N. pour IFT 1810
Conseils pratiques :

a) 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.

b) 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

c) 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.

d) 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, ...

e) 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

3) 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

Chapitre 2 : Éléments de base de la programmation 22

Préparé par Le Van N. pour IFT 1810
 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).

Chapitre 2 : Éléments de base de la programmation 23

Préparé par Le Van N. pour IFT 1810
4) Nature de l'information

4.1) 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

Chapitre 2 : Éléments de base de la programmation 24

Préparé par Le Van N. pour IFT 1810
 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.

Chapitre 2 : Éléments de base de la programmation 25

Préparé par Le Van N. pour IFT 1810
 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';

4.2) 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;

5) 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;

Chapitre 2 : Éléments de base de la programmation 26

Préparé par Le Van N. pour IFT 1810
 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;

6) 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;

7) Opérateurs de base

7.1) 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)

Chapitre 2 : Éléments de base de la programmation 27

Préparé par Le Van N. pour IFT 1810
 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)

7.2) 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

Chapitre 2 : Éléments de base de la programmation 28

Préparé par Le Van N. pour IFT 1810
 Exemples :

17 < 23 vaut 1
'c' != 'C' vaut 1
17 % 5 == 4 vaut 0 ( 17 % 5 donne 2, 2 == 4 est faux )

7.3) 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)

B) É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.

1) 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)).

Chapitre 2 : Éléments de base de la programmation 29

Préparé par Le Van N. pour IFT 1810
 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)

2. 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)
3. printf("age = %3d, Nombre de tasses de cafe = %4d", age, nbCafe);

fait afficher : age = ^23, Nombre de tasses de cafe = ^^^3

4. printf("age : %4d\n", age);

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

fait afficher : age : ^^23

Nombre de tasses de cafe : ^^^3

Chapitre 2 : Éléments de base de la programmation 30

Préparé par Le Van N. pour IFT 1810
 5. 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

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

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

7. 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)

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.

Chapitre 2 : Éléments de base de la programmation 31

Préparé par Le Van N. pour IFT 1810
2) 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
Chapitre 2 : Éléments de base de la programmation 32
Préparé par Le Van N. pour IFT 1810
 2. 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.

3. 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é) */

4. 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

Chapitre 2 : Éléments de base de la programmation 33

Préparé par Le Van N. pour IFT 1810
C) Instructions de base en langage C

1) 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;

2) 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;
}

Chapitre 2 : Éléments de base de la programmation 34

Préparé par Le Van N. pour IFT 1810
3) Instructions de sélection (de décision)

3.1) La sélection simple

a) Syntaxe

if (condition) if (condition)
instruction 1 o instruction 1
else u
instruction 2

faux vrai faux vrai

condition condition

instruction 2 instruction 1 instruction 1

b) 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.

c) 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).

d) Exemples

1) if (age <= 11)

printf("C'est un enfant\n");
else

Chapitre 2 : Éléments de base de la programmation 35

Préparé par Le Van N. pour IFT 1810
 printf("C'est un adolescent ou un adulte\n");

2) if (sexe == 'f' || sexe == 'F')

nbFemmes = nbFemmes + 1;

3) if (sexe == 'm' || sexe == 'M'){

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

4) 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)

Chapitre 2 : Éléments de base de la programmation 36
Préparé par Le Van N. pour IFT 1810
 printf("C'est un homme de plus de 60 ans");

Chapitre 2 : Éléments de base de la programmation 37

Préparé par Le Van N. pour IFT 1810
  É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");

Chapitre 2 : Éléments de base de la programmation 38

Préparé par Le Van N. pour IFT 1810
 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);

Chapitre 2 : Éléments de base de la programmation 39

Préparé par Le Van N. pour IFT 1810
 /* 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...

*/

Chapitre 2 : Éléments de base de la programmation 40

Préparé par Le Van N. pour IFT 1810
3.2) La sélection multiple avec switch ... :

a) Syntaxe : cette instruction est semblable à Select Case ... en Visual Basic.

Le switch permet de construire une table de

branchement à partir d'une expression. Il remplace
switch (expression){ avantageusement une suite de if imbriqués.
case valeur1: L'expression expression est évaluée, puis elle branche
instructions1; directement sur le bon cas case s’il est défini. Les
break;
valeurs valeur1, valeur2,… , valeurn, doivent être des
case valeur2: valeurs de type entier ou de type caractère. Si le
instructions2; branchement est trouvé, les énoncés qui suivent le case
break; 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
case valeurn: force, du même coup, la fin de l'instruction switch. Si le
instructionsn; résultat de l'expression ne correspond à aucun
break; branchement, les instructions correspondant au
branchement default, s'il existe, seront exécutées.
default:
instructionsn+1; Il est possible d'accepter plus d'une valeur pour une
break; 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");

Chapitre 2 : Éléments de base de la programmation 41

Préparé par Le Van N. pour IFT 1810
 }

Chapitre 2 : Éléments de base de la programmation 42

Préparé par Le Van N. pour IFT 1810
b) 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 :

o si oui :

on exécute les instructions à partir de ce cas jusqu'à ce

qu'on rencontre :

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

. la fin du "switch"

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

o 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.

c) 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.

Chapitre 2 : Éléments de base de la programmation 43

Préparé par Le Van N. pour IFT 1810
 d) Exemples

Exemple 1 (deuxième solution de l'exercice situé aux pages 39)

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 boni à accorder dépendant du poste

 d'afficher à l'écran un message du genre :

Chapitre 2 : Éléments de base de la programmation 44

Préparé par Le Van N. pour IFT 1810
 C'est un opérateur qui gagne 567.89 $ par semaine et reçoit 400.00
$ de bonus.

Chapitre 2 : Éléments de base de la programmation 45

Préparé par Le Van N. pour IFT 1810
 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);
}

Chapitre 2 : Éléments de base de la programmation 46

Préparé par Le Van N. pour IFT 1810
 e) 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.

Chapitre 2 : Éléments de base de la programmation 47

Préparé par Le Van N. pour IFT 1810
 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.

Chapitre 2 : Éléments de base de la programmation 48

Préparé par Le Van N. pour IFT 1810
 #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");

Chapitre 2 : Éléments de base de la programmation 49

Préparé par Le Van N. pour IFT 1810
 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...

*/

Chapitre 2 : Éléments de base de la programmation 50

Préparé par Le Van N. pour IFT 1810
D) É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;

E) 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.

Chapitre 2 : Éléments de base de la programmation 51

Préparé par Le Van N. pour IFT 1810
 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 ");
....

F) 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 :

Adresse
Chapitre 2 : Éléments de base de la programmation 52
Préparé par Le Van N. pour IFT 1810
 1245033
1245032
1245031
1245030

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));
Chapitre 2 : Éléments de base de la programmation 53
Préparé par Le Van N. pour IFT 1810
 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)

Nom Valeur Adresse Commentaire

a 4202496 adresse du début de a
5

b
23
4202500 adresse de b
x
123.4
4202504 adresse de x
Chapitre 2 : Éléments de base de la programmation 54
Préparé par Le Van N. pour IFT 1810
 d ‘V’
INUTILISÉ
INUTILISÉ
INUTILISÉ 4202508 adresse de d
c
100
4202512 adresse de c
taille

1.72

4202520 adresse de taille

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.

Chapitre 2 : Éléments de base de la programmation 55

Préparé par Le Van N. pour IFT 1810
G) 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

Chapitre 2 : Éléments de base de la programmation 56

Préparé par Le Van N. pour IFT 1810