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
(6.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)
Chapitre 2 : Éléments de base de la programmation IFT 1969 / A07 Page 1

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

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

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% à 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.06

#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 1969, 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 de

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();
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 = (Nb_Pieds + Nb_Pouces / 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 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 : Féminin\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");

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

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

 Écrire une instruction permettant de vérifier si un caractère
(unCar de type char) est une voyelle.
Solution :
#include <stdio.h>
#include <ctype.h> /* nécessaire pour utiliser
la fonction toupper */
int main()
{
char unCar;
printf("Entrez un caractere : ");

fflush(stdin);
scanf("%c", &unCar);
unCar = toupper(unCar); /* convertir en MAJUSCULE */
if (unCar == 'A' || unCar == 'E' ||

unCar == 'I' || unCar == 'O' ||
unCar == 'U' || unCar == 'Y')
printf("C'est une voyelle!");
else
printf("Ce n'est pas une voyelle");
return 0 ;
}
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
#include <stdio.h>
/* Auteurs : Eglesias Julien, Section C et

Yetov May, Section D
Date : 13 septembre 2007 pour le cours IFT 1969
But : Ce programme permet de saisir le rang d'une journée et

d'afficher un message pertinent selon la valeur du rang
saisi
*/
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)
printf("La fin semaine s'en vient");
else if (rang == 1 || rang == 7)
printf("Youpi! C'est la fin semaine!");
else
printf("Rang invalide!");
printf("\n");
return 0;
}
Exécution
Entrez le rang d'une journee (entre 1 et 7) : 2

On travaille tres fort!

La fin semaine s'en vient

Youpi! C'est la fin semaine!

Rang invalide

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
instructions1;
branche directement sur le bon cas case s’il est
break;
défini. Les valeurs valeur1, valeur2,… , valeurn,
case valeur2: doivent être des valeurs de type entier ou de type
instructions2; caractère. Si le branchement est trouvé, les
break; é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 à
case valeurn: exécuter pour un case particulier et force, du même
instructionsn; coup, la fin de l'instruction switch. Si le résultat de
break; l'expression ne correspond à aucun branchement,
les instructions correspondant au branchement
default:
instructionsn+1; default, s'il existe, seront exécutées.
break; 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");

}

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é à la page 21)
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)*/
int 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);
return 0 ;
}

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 : Gontran Grondin, Section C et Olit Ye, Section D *
* *
* Date : 20 septembre 2007 pour le cours IFT 1969 *
* *
* 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éterminer si *
* le mois a 28 ou 29 jours au mois de fevrier *
*********************************************************************/
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 2007) : ");
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 2007) : ");
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");
return 0 ;
}

Exécution
Entrez le rang d'un mois (entre 1 et 12) : 9
Solution avec if ...... :

Le mois de rang 9 a 30 jours
Solution avec switch ...... :

30 jours

Le mois de rang 10 a 31 jours

31 jours

Le mois de rang 2 est fevrier. On a besoin de l'annee
Entrez l'annee (exemple 2007) : 1996
On a 29 jours en fevrier 1996

On a besoin de l'annee

Le mois de rang 2 est fevrier. On a besoin de l'annee
L'annee 1900 a un mois de fevrier de 28 jours

On a besoin de l'annee

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 1160, suite de IFT
1969).
 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;
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("\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));
return 0 ;
}
Exécution
L'exécution du programme avec Microsoft Visual C++ sur un IBM ThinkPad (Pentium
3 celeron) donne ce qui suit :

Nom Type Nb. octets Adresse Valeur
--- ----- ---------- ------- ------
a int 4 1245052 5
b int 4 1245048 23
x float 4 1245044 123.40
d char 1 1245040 V
c int 4 1245036 100
L'operateur * (contenu de l'adresse) :

Le contenu a l'adresse 1245048 est 23
Le contenu a l'adresse 1245044 est 123.40
Press any key to continue
L'opérateur * signifie : le contenu à l'adresse.

Le contenu à l'adresse 1245048 est 23.
Le contenu à l'adresse 1245044 est 123.4
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). Lire le
tableau du bas vers le haut. 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
5
a 1245052 adresse du début de a
23
b 1245048 adresse du début de b
123.4
x 1245044 adresse du début de x
INUTILISÉ
INUTILISÉ
INUTILISÉ
d 'V' 1245040 adresse du début de d

100
c 1245036 adresse du début de c
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)
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

Autres exemples
Exemple 1
/***********************************************************************
* carac.c *
* Cours : IFT 1969 *
* Auteur : Gontran Grondin *
* Description : Ce programme permet de déterminer si un caractère est *
* un chiffre ou une voyelle *
* Date : 12 décembre 2007 *
***********************************************************************/
#include <stdio.h>
int main()
{
char carac; /* le caractere a analyser */
printf("Entrez un caractere SVP: ");

scanf(" %c", &carac);
switch (carac )
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': printf("%c'est un chiffre\n\n", carac);
break;
case'A':
case'a':
case'E':
case'e':
case'I':
case'i':
case'O':
case'o':
case'U':
case'u':
case'Y':
case'y': printf("%c'est une voyelle\n\n", carac);
break;
default : printf("%c'est ni un chiffre, ni une voyelle\n\n",
carac);
}
return 0 ;
}

Exemple 2
Même programme que l'exemple 1 mais avec des if imbriqués (cf la table
des codes ASCII à l'annexe D)
/***************************************************************************
* carac_if.c *
* Cours : IFT 1969 *
* Auteur : Pierre Trochu *
* Description : Ce programme permet de déterminer si un caractère est *
* un chiffre ou une voyelle *
**************************************************************************/
#include <stdio.h>
int main()
{
char carac; /* le caractère à analyser */
printf("Entrez un caractere SVP: ");

scanf(" %c", &carac);
if (carac >= 48 && carac <= 57)
printf("%c'est un chiffre\n\n", carac);
else if (carac == 65 || carac == 69 || carac == 73 ||
carac == 79 || carac == 85 || carac == 89 ||
carac == 97 || carac == 101 || carac == 105 ||
carac == 111 || carac == 117 || carac == 121)
printf("%c'est une voyelle\n\n", carac);
else
printf("%c'est ni un chiffre, ni une voyelle\n\n", carac);
return 0 ;
}
Remarque:
/* comme dans un exemple au début du chapitre, on aurait pu aussi écrire

*/
if (carac >= '0' && carac <= '9')

printf("%c'est un chiffre\n\n", carac);
else if (carac == 'A' || carac == 'E' || carac == 'I' ||
carac == 'O' || carac == 'U' || carac == 'Y' ||
carac == 'a' || carac == 'e' || carac == 'i' ||
carac == 'o' || carac == 'u' || carac == 'y')
printf("%c'est une voyelle\n\n", carac);
else
printf("%c'est ni un chiffre, ni une voyelle\n\n", carac);

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

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

2) Identification d'une information

Dans notre vie quotidienne, nos noms et prénoms nous permettent de

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

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

Les identificateurs suivants sont invalides :

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

Chapitre 2 : Éléments de base de la programmation IFT 1969 / A07 Page 1

Chapitre 2 : Éléments de base de la programmation IFT 1969 / A07 Page 2

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

b) Longueur maximale d'un identificateur :

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

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

d) Identificateurs prédéfinis ou réservés qui sont reconnus par le compilateur

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

Chapitre 2 : Éléments de base de la programmation IFT 1969 / A07 Page 3

Écrire les déclarations des variables suivantes :

Écrire les déclarations des variables suivantes :

char sexe, poste;

Exercice (sans solution)

Écrire les déclarations des variables représentant les informations

Chapitre 2 : Éléments de base de la programmation IFT 1969 / A07 Page 4

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

Quand doit-on déclarer les constantes? :

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

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

Comment peut-on déclarer les constantes? :

#define identificateur valeur

#define TAUX_TPS 0.06

#define BAREME_INTRA 0.20

#define FEMININ 'F'

Chapitre 2 : Éléments de base de la programmation IFT 1969 / A07 Page 5

La directive #define fait remplacer le nom de la constante par sa

Chapitre 2 : Éléments de base de la programmation IFT 1969 / A07 Page 6

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 IFT 1969 / A07 Page 7

int age = 17, anciennete, nbAdulte = 0;

On utilise des commentaires pour décrire le but d'un programme, pour

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

Les opérateurs arithmétiques permettent de faire des calculs entre des

3 * 5.4 vaut 16.2

10 / 4 vaut 2 (la division entre 2 entiers donne un entier comme

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)