Chapitre 2

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

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

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

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';
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;

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)

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

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

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

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.

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

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

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

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)

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

*/

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

}

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.

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 :

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

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.

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

*/

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.

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

*/
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
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.

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

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 2

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 2

Transféré par

Droits d'auteur :

Formats disponibles

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

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

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

2) Identification d'une information

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

Il est maintenant permis d'utiliser des caractères accentués à l'intérieur d'un

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

a) Un identificateur sert à nommer une information (une donnée, un résultat, un

b) Longueur maximale d'un identificateur :

Cette longueur change d'un langage à un autre, d'un compilateur à un autre et

On vous conseille d'utiliser des identificateurs significatifs de longueur

c) Les compilateurs C font la différence entre les identificateurs écrits en

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

int main(), int, float, const, ...

e) Erreurs fréquemment commises sur les identificateurs :

1ertp Faux commence par un chiffre

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

Écrire les déclarations des variables suivantes :

Écrire les déclarations des variables suivantes :

char sexe, poste;

Exercice (sans solution)

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

4.1) Les constantes

On distingue deux catégories de constantes :

 les constantes éternelles : 2, 17. 3, 3.14159 (PI), ...

Quand doit-on déclarer les constantes? :

 pour généraliser le programme : les barèmes, les taux de taxes, les

 pour éviter des erreurs de frappe ou pour donner plus de précision

Comment peut-on déclarer les constantes? :

#define identificateur valeur

#define TAUX_TPS 0.05

#define BAREME_INTRA 0.20

#define FEMININ 'F'

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

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

const type nom = valeur ....

const int BORNE_ADULTE = 18;

4.2) Les variables

type liste de variable(s);

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

int age = 17, anciennete, nbAdulte = 0;

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

/* But du programme : Ce programme permet de .... */

/* Conversion de la taille en mètre : */

7.1) Opérateurs arithmétiques

3 * 5.4 vaut 16.2

10 / 4 vaut 2 (la division entre 2 entiers donne un entier comme résultat, on

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)