Université de Thiès Licence 2 - Science physique

Informatique Générale – Algorithme &

Programmation

Responsable du cours

Mamadou Lamine DIA

1
ORGANISATION DU COURS
INTRODUCTION A L’INFORMATIQUE
ALGORITHME
PROGRAMATION : LANGAGE C

2
INTRODUCTION A l’INFORMATIQUE

3
Qu’est ce que l’informatique?
• INFORmation autoMATIQUE
• Définition de Wikipédia: L'informatique est un domaine d'activité
scientifique, technique et industriel concernant le traitement
automatique de l'information par l'exécution de programmes
informatiques par des machines : des systèmes embarqués, des
ordinateurs, des robots, des automates, etc.
• Les champs d’application peuvent être séparés en deux branches:
- nature théorique, qui concerne la définition de concepts et
modèles: modélisation, algorithme, etc.
-nature pratique, qui s'intéresse aux techniques concrètes de mise en
œuvre: programmation, etc.
4
 Disciplines de l’informatique
• Informatique théorique: algorithme, calculabilité, complexité, modélisation, etc.
• Programmation
• Réseaux, logiciel de télécommunication, sécurité des échanges d’information
• Logiciels de base: système d’exploitation, bases de données, compilateurs, etc.
• Systèmes embarqués, robotique
• Images, son, multimédia, Interfaces homme/machine, …
• Système d’information
• Calcul scientifique, optimisation, intelligence artificielle, bio-informatique,…

5
Domaines d’application de l’informatique
• Informatique de gestion
- Comptabilité, facturation, paye, gestion des stocks et du système de
production, gestion des relations clients, banques et bourse, aide à la décision, …
• Informatique industrielle et technologique
- Conception et fabrication assistées, modélisation et simulation de
systèmes complexes, informatique embarquée, télécommunications et
réseaux,…
• Internet
- E-commerce, recherche d’information, sécurité,…
• Et aussi disciplines scientifiques, médicales, métrologique, …

6
Métiers de l’informatique
• Métiers de l’exploitation
- Maintenance, support, administrateur de système d’information, de système, de réseau, …
• Métiers de la conception et du développement:
- Analyste-programmeur, concepteur de logiciel, architecte de système d’information, web
designer, …
• Métiers de recherche
- En informatique « pure » ou appliquée à d’autres domaines
• Métiers du conseil et de l’expertise
- Mise en place de système d’information, protocoles de sécurité, …
• Métiers du marketing:
- Ingénieur technico-commercial, chef de produit, …

7
Comment ça marche?
• Le processeur est constitué de circuits électronique
programmables par suite d’instructions (le
programme), une suite de 0 et de 1, indiquant s’il
doit passer ou non du courant électrique
• Les instructions sont dans la mémoire (elles sont
chargées dans la mémoire à partir d’un support
externe: disque dur, …)
• Les instructions peuvent lire ou écrire des données
dans des registres (accumulateur sur le dessin) ou
dans des « cases » de la mémoire (mot-mémoire)
identifiées par leur adresse (un nombre entier)
8
Notion de langage de programmation
• Le langage machine binaire
- C’est celui qui est stocké sur les disques (.exe par exemple), et
amené en mémoire pour être exécuté. C’est une suite de 0 et 1
• Pour un être humain écrire des 0 et 1 n’est pas évident, pas bien
lisible et cause de nombreuses erreurs
- On a donc inventé les langages de programmation, qui étaient
d’abord une simple forme symbolique des instructions, puis qui sont
devenus de plus en plus évolués et éloignés de la machine

9
Comment la machine « comprend » un
langage de programmation?
• Il faut un programme qui
- Soit traduit le texte de votre programme en code binaire, on a affaire à
un compilateur:
données

programme programme
source compilateur binaire résultats

- Ou exécute votre programme (gardé en mémoire sous une

forme plus appropriée que la forme textuelle), on a alors un
interpréteur: moins rapide par nature
• Modèle mixte: le compilateur traduit dans le langage d’une
10
machine virtuelle, interprété par un simulateur de cette machine
Système d’exploitation
• C’est le programme responsable d’organiser les échanges entre les ressources
matérielles de l’ordinateur et les programmes lancés par l’utilisateur(ou activités
derrière son dos): Linux, Windows, MacOs,…
• Un noyau pour:
- Gestion des périphériques (pilotes - drivers) et du réseau
- Gestion de la mémoire et ordonnancement des différents processus(les
programmes qui tournent)
• Une interface utilisateur(lignes de commande – clavier ou interface graphique –
souris – fenêtres)
• Des bibliothèques (sous programmes souvent utilisés) et des outils de gestion et
d’observation du système
11
Système de gestion de fichiers (SGF)
• SGF: structure de données arborescente stockant les informations des mémoires
secondaires (disque dur, CD-ROM, clé USB, …)
• Il assure plusieurs fonctions:
- Créer/détruire/modifier un fichier
- Allocation de la place sur mémoires secondaires
- Localisation des fichiers (chemin d’accès)
- Sécurité et contrôle (propriétaire, qui peut lire/écrire, …)
• Principaux systèmes de fichier:
- FAT32, VFAT (non journalisé, Windows)
- ext[2,3,4] (Linux), NTFS (Windows), …
12
ALGORITHME

13
 Introduction
Un algorithme est une recette à suivre pour arriver à un certain résultat (et
même à un résultat certain). Plus précisément :
Un algorithme est un ensemble d'instructions permettant de résoudre un
problème, autrement dit de fournir un résultat à partir de données.
La rédaction préalable des algorithmes permet plusieurs choses :
• d’être compréhensible par tout informaticien même s'il ne connaît pas le langage du
programme ;
• de rester focalisé sur la logique du programme et non sur les particularités du langage
utilisé ;
• de vérifier la complexité du programme et donc de l'optimiser ;
• de faire ressortir de manière compréhensible les cas d’utilisations.

14
SCENARIO D’UN TRAITEMENT
AUTOMATIQUE
• Pour effectuer un traitement automatique avec la machine il faut:
• indiquer la source de données (sur quoi porte le traitement)
• les opérations ou actions élémentaires à effectuer
• la destination où les résultats sont renvoyés
• Les étapes de l’exécution d’un programme
• Le processeur extrait les données à traiter à partir de la source indiquée dans le
programme (soit auprès de l'utilisateur qui devrait les introduire au moyen du
clavier, soit en mémoire secondaire ou centrale).
• Il exécute, ensuite, la série d'opérations élémentaires de manière séquentielle (dans
l'ordre prévu par le programme) et mémorise tous les résultats intermédiaires.
• Il renvoie enfin le ou les résultats attendus à la destination (périphérique de sortie)
indiquée dans le programme.
15
Exemple
Pour calculer le montant total d’une facture de téléphone pour des
appels locaux effectués le soir, le programmeur doit préciser au
processeur :
• les données (les entrées consommation, prix_unitaire, la TVA et le
prix_d_abonnement) à demander à l'utilisateur.
• l'ordre des opérations à faire et les résultats intermédiaires à
mémoriser (dans cet exemple, il s'agit de calculer respectivement le
prix hors taxe (PHT) et le prix total (PT).
• Le résultat final (PT) à afficher.

16
Exemple: Algorithme
Lire (consommation, prix_unitaire,TVA, prix_d_abonnement)
PHT  (consommation * prix_unitaire) + prix_d_abonnement
PT  PHT * (1+TVA)
Ecrire PT
Dans le cas où on donne une consommation de 100 unités avec 50 FCFA comme prix
unitaire, 0.2 comme taux de la TVA et 700 FCFA comme prix d’abonnement, le
processeur, après avoir demandé les données (100, 50, 0.2 et 700) à l'utilisateur, calcule
dans l'ordre indiqué chaque expression élémentaire et mémorise son résultat :
PHT=(100*50)+700=5700
PT=5700*(1+0.2)=6840
Il affiche enfin le résultat final PT (6840).

17
NOTION D’ALGORITHME
• Le terme algorithme est employé en informatique pour décrire une méthode de résolution de
problème programmable sur machine.
• Un algorithme est une suite finie et ordonnée d'opérations (actions) élémentaires finies (en temps
et moyens). Elle est régie par un ensemble de règles ou d'instructions de contrôle (séquencement,
sélection et itération) permettant d'aboutir à un résultat déterminé d’un problème donné.
Exemple1:
Creuser un trou, reboucher un trou et placer un arbre dans un trou sont des opérations
élémentaires (des actions simples) que toute personne (machine dans le cas de l'informatique) est
censée savoir exécuter. Néanmoins, si un jardinier (programmeur) veut faire planter un arbre par
une personne qui ne sait pas le faire, il doit lui fournir "un descriptif" (un algorithme) qui lui indique
les opérations à faire ainsi que leur ordre d'exécution (séquencement).
Algorithme de plantation d'un arbre
1- Creuser un trou.
2- Placer l'arbre dans le trou.
3- Reboucher le trou.
18
NOTION D’ALGORITHME
• Exemple2:
Pour planter et arroser un ensemble d'arbres, on peut procéder de la manière suivante: planter l'ensemble
d'arbres et les arroser tous à la fin.
Algorithme de plantation et d'arrosage de plusieurs arbres
1- Creuser un trou.
2- Placer un arbre dans le trou.
3- Reboucher le trou.
4- S'il existe encore des arbres exécuter les actions 1, 2, 3 et 4.
Sinon exécuter les actions suivantes.
5- Arroser les arbres.
L'algorithme correspondant indique un ensemble d'opérations (1, 2, 3 et 4) à répéter un certain nombre de fois
(règle d'itération) et l'opération ou les opérations (5 ou 1, 2, 3 et 4) à exécuter selon qu'il reste ou non des
arbres à planter (règle de sélection).
Remarque:
Pour résoudre le problème précédent, on peut procéder autrement : planter et arroser arbre par arbre. On
conclut alors qu'à un problème donné pourraient correspondre plusieurs algorithmes.
19
OPERATIONS DE BASE
• L'AFFECTATION
• L'affectation, notée par le symbole , est l'opération qui évalue une expression (constante ou
une expression arithmétique ou logique) et attribue la valeur obtenue à une variable.
• Variable  expression
• Exemple: a  10; a  (a*b)+c; d  ‘m ’
• LA LECTURE
• Cette opération permet d'attribuer à une variable une valeur introduite au moyen d'un organe
d'entrée (généralement le clavier).
• Lire variable
• Exemple: Lire a; Lire(a,b,c), …
• L'ECRITURE
• Elle communique une valeur donnée ou un résultat d'une expression à l'organe de sortie.
• Ecrire expression
• Exemple: Ecrire 'bonjour’; Ecrire 12; Ecrire a,b,c; Ecrire a+b
20
INSTRUCTIONS DE CONTROLE
1. Instruction Si
Si condition alors
Début
instruction(s) 1
Fin
Sinon
Début
instruction(s) 2
Fin

• Elle indique le traitement à faire selon qu’une condition (expression logique) donnée est satisfaite ou non.
• Il est possible d’omettre début et fin si le bloc d’instructions à exécuter est constitué d’une seule instruction.
• Exemple : lire CA
Si CA<5000 alors
• Calculer la taxe sur le chiffre d'affaire (CA) sachant qu'elle est de :
Taxe  CA*10%
• 10% si le CA<5000DH
Sinon
• 20% si le CA >=5000DH
Taxe  CA*20%
• Exemple d'algorithme utilisant l'instruction Si Ecrire Taxe
21
 INSTRUCTIONS DE CONTROLE
• Remarques:
1- Une instruction de contrôle peut se réduire à : 2- On peut avoir plusieurs si imbriqués comme:
Si condition alors Si condition1 alors
Début Si condition2 alors
instruction(s) Si condition3 alors
Fin <instruction(s) 1>
Sinon
<instruction(s) 2>
Exemple: Sinon
Vérifier si un agent a droit de bénéficier du crédit de logement ou non <instruction(s) 3>
selon ses années d’ancienneté et sa note d’appréciation.
lire (ancienneté, note)
Sinon
Si ancienneté < 5 alors <instruction(s) 4>
Si ancienneté=4 et note≥16 alors
écrire ('L’agent a droit de bénéficier du crédit’)
Sinon
Si ancienneté=3 et note≥18 alors
écrire ('L’agent a droit de bénéficier du crédit’)
Sinon
écrire ('L’agent n’a pas droit de bénéficier du crédit’)
Sinon
Si note≥13 alors
écrire ('L’agent a droit de bénéficier du crédit’)
Sinon
écrire ('L’agent n’a pas droit de bénéficier du crédit')
22
INSTRUCTIONS DE CONTROLE
2. Instruction Selon
Selon variable
Elle indique le traitement à faire selon valeur1 : instruction(s) 1
valeur2 : instruction(s) 2
la valeur d'une variable. ...
valeurn : instruction(s) n
sinon instruction(s) m
Exemple:
Vérifier et Afficher si un caractère saisi est une voyelle ou consonne.
lire c
Selon c
'a' : écrire ('le caractère est une voyelle')
'e' : écrire ('le caractère est une voyelle')
'i' : écrire ('le caractère est une voyelle')
'o' : écrire ('le caractère est une voyelle')
'u' : écrire ('le caractère est une voyelle')
'y' : écrire ('le caractère est une voyelle')
sinon écrire ('le caractère est une consonne') 23
 INSTRUCTIONS ITERATIVES
1. Instruction Pour
• Elle permet de répéter un traitement un nombre Pour compteur  valeur1 à valeurn faire
Début
de fois précis et connu en utilisant un compteur Instruction(s)
Fin
(variable à incrémenter d'une itération à l'autre).
Exemple :
Afficher la somme des entiers compris entre 0 et une valeur n saisie au clavier
(n≥0).
lire n
s0
Pour i  1 à n faire
Début
s  s+i
Fin
écrire s
24
INSTRUCTIONS ITERATIVES
2. Instruction Tant que
Tant que condition faire
Elle permet de répéter un traitement Début
instruction(s)
tant qu'une condition est satisfaite. Fin
Exemple :
Calculer la somme s des entiers compris entre 0 et un nombre n saisi au
clavier (on suppose que n≥0).
lire n
Remarque : s0
Tant que n > 0 faire
Dans le cas d'utilisation de l'instruction Début
tant que, si la condition est fausse au s  s+n
n  n-1
départ, le bloc d'instructions ne sera pas Fin
Ecrire s
du tout exécuté (Dans l'exemple ci-dessus,
c'est le cas où n  0 au départ). 25
INSTRUCTIONS ITERATIVES
3. Instruction Faire Tant que Faire
Début
Elle permet de répéter un traitement instruction(s)
Fin
tant qu'une condition est satisfaite. Tant que condition
Exemple :
Calculer la somme s des entiers compris entre 0 et un nombre n saisi au
clavier. lire n
Remarque: s0
i0
Dans le cas d'utilisation de l'instruction Faire Tant que, Faire
Début
le bloc d'instructions est exécuté au moins une fois s  s+i
i  i+1
quelle que soit la condition. Fin
Tant que i≤n
Ecrire s
26
ETAPES ET DEMARCHES DE
RESOLUTION ALGORITHMIQUE

27
 CYCLE DE VIE D'UN ALGORITHME (1)
Résoudre un problème par ordinateur consiste à lui fournir un programme (suite
d'opérations) qu'il est capable d'exécuter. L'élaboration d'un programme est réalisée suite à
une série d'étapes d'analyse du problème en question, de développement et d'évaluation
en vue d'aboutir à l'algorithme adéquat.
 DEFINITION DU PROBLEME
A cette étape, il s'agit de répondre aux questions suivantes :
• Quelles sont les données du problème (entrées) ?
• Quelles sont les résultats demandés (sorties) ?
• Quel(s) est/sont le(s) traitement(s) à effectuer ?
• Quels sont les erreurs ou cas particuliers susceptibles de se produire et les solutions à proposer ?
 PLANIFICATION
Elle consiste à décomposer le problème à traiter en sous problèmes plus simples à
résoudre.
A cette étape, une analyse par l'exemple aide souvent à dégager les grandes lignes d’un
algorithme. 28
 CYCLE DE VIE D'UN ALGORITHME (2)
 DEVELOPPEMENT
Il consiste à effectuer une analyse des sous problèmes obtenus à l'étape 2 en
procédant par une démarche descendante ou ascendante. La première démarche
consiste à détailler progressivement le problème en opérations plus simples
exécutables par la machine. Par ailleurs, la deuxième démarche consiste à traiter
le cas simplifié du problème tout en l’enrichissant progressivement jusqu’à
résolution finale du problème complexe.
Remarque:
A un problème donné, peuvent correspondre plusieurs découpages en sous-
problèmes conduisant à des algorithmes différents.

29
 CYCLE DE VIE D'UN ALGORITHME (3)
 VALIDATION
A cette étape, on doit s'assurer que l'algorithme final répond à toutes les spécifications du problème définies à
l'étape 1.
Pour valider son algorithme, le programmeur peut faire appel dans un premier temps à la trace de l'algorithme. Il
s'agit de la simulation du fonctionnement ou de l'exécution du programme. Elle permet de vérifier si l'algorithme
répond à un cas donné et aide également à déduire le type de problème traité par l'algorithme en question.
Néanmoins, la trace d'un algorithme ne permet pas de confirmer sa validité pour tous les cas possibles. Le
programmeur est amené ensuite à dégager l'ensemble de classes de valeurs pouvant constituer les entrées en jeu
pour évaluer et valider son algorithme.
 CODIFICATION
A cette étape, l'algorithme obtenu doit être codé en un langage de programmation au choix.
 VERIFICATION ET MISE AU POINT
Il s'agit, à cette étape, de rendre le programme opérationnel : corriger les erreurs et vérifier
les résultats.
Le compilateur du langage utilisé aide à détecter les erreurs de syntaxe (mais non pas de conception et de logique).
Une fois ces erreurs corrigées, il traduit le programme source en programme exécutable. Le programmeur alors
pourra faire un jeu d'essais. 30
 EXEMPLE DE LA DEMARCHE DESCENDANTE (1)
En procédant par la démarche de résolution descendante, le programmeur part comme on
vient de le signaler du général au particulier en détaillant le problème en actions plus
simples jusqu’à résolution du problème.
Exemple : Division Euclidienne
Calculer le quotient Q et le reste R de deux nombres entiers positifs A et B.
Définition du problème
Entrées : Les deux nombres entiers positifs A et B.
sorties : Le quotient Q et le reste R.
Traitement : Calculer le quotient Q et le reste R de la division de A par B.
Cas particuliers : B=0.
Version 1 de l'algorithme :
Début
1- Lire A et B
2- Calculer le quotient Q et le reste R de la division de A par B
3- Ecrire (Q, R)
31
Fin
 EXEMPLE DE LA DEMARCHE DESCENDANTE (2)
Planification
Analyse par l'exemple :
Prenons le cas de A=13 et B=4.
Si on suppose que les seules opérations arithmétiques que la machine puisse exécuter sont
la soustraction et l'addition de deux nombres, on tâchera alors de résoudre le problème
moyennant ces deux opérations. Aussi, nous procédons par des soustractions pour trouver
le quotient et le reste.
1- 13-4=9
2- 9-4=5
3- 5-4=1
4- 1-4=-3 (on ne peut pas continuer)  Q=3 et R=1
Nous remarquons que :
• Q est le nombre de fois que l'on peut effectuer la soustraction.
• R est le résultat de la dernière opération. 32
 EXEMPLE DE LA DEMARCHE DESCENDANTE (3)
Version 2 de l'algorithme :
Début
1- Lire (A,B)
2- Soustraire B de A autant de fois que c'est possible
3- Q est égale au nombre de soustractions effectuées
4- R est le résultat de la dernière soustraction
5- Ecrire (Q, R)
Fin
Développement avec la démarche descendante
Version 3 de l'algorithme :
Début
1- Lire (A,B)
2- Poser Q=0
3- Tant que la soustraction A-B est possible faire
Début
4- Soustraire B de A
5- Additionner 1 à Q
Fin
6- Poser R=A
7- Ecrire (Q, R)
33
Fin
 EXEMPLE DE LA DEMARCHE
DESCENDANTE (4)
Version 4 de l'algorithme :
Début
1- Lire (A,B)
2- Q  0
3- Tant que A≥B faire
Début
4- A  A-B
5- Q  Q+1
Fin
6- R  A
7- Ecrire (Q, R)
Fin

34
 EXEMPLE DE LA DEMARCHE DESCENDANTE (4)
Validation de l’algorithme
Trace de l'algorithme pour A=11 et B=5 :
Opération A B Q R
1 11 5 - -
2 11 5 0 -
3 11 5 0 -
4 6 5 0 -
5 6 5 1 -
3 6 5 1 -
4 1 5 1 -
5 1 5 2 -
3 1 5 2 -
6 1 5 2 1
7 1 5 2 1

On remarque que le résultat final est correct pour le cas A=11 et B=5. Mais, il reste
à valider l'ensemble de cas possibles. 35
 EXEMPLE DE LA DEMARCHE
DESCENDANTE (5)
Validation par classes de valeurs d'entrées :
Cas où A=0 et B 0, on obtient R=A et Q=0.
Cas où A 0 et B=0, le programme bouclera infiniment.
Cas où A=0 et B=0, le programme bouclera infiniment.
Cas où A 0 et B 0, nous avons à valider deux cas :
Cas où A<B, on obtient R=A et Q=0.
Cas où A=B, on obtient R=0 et Q=1.
Cas où A>B, on peut constater qu'au bout d'un nombre fini de fois A devient plus petit que B ;
D'où l'arrêt de la boucle.
Nous remarquons que l'algorithme ne marche pas quand B est égale à 0. Il s'agit
donc d’un cas particulier dont il faut tenir compte dans l'algorithme.
36
 EXEMPLE DE LA DEMARCHE DESCENDANTE (6)
Version 5 de l'algorithme :
Début
1- Lire (A,B)
2- Si B=0 alors
3- Ecrire ('Impossible de faire des divisions par 0')
4- Sinon
Début
5- Q  0
6- Tant que A≥B faire
Début
7- A  A-B
8- Q  Q+1
Fin
9- R  A
10- Ecrire (Q, R)
Fin
Fin
Pour les autres cas, nous constatons que l'algorithme s'arrête au bout d'un temps fini.
Néanmoins, nous ne pouvons pas confirmer la pertinence des résultats obtenus (s'ils sont corrects ou non). Un
jeu d'essai s'avère alors nécessaire mais encore insuffisant pour la validation de l'algorithme. 37
 EXEMPLE DE LA DEMARCHE ASCENDANTE (1)
En procédant par la démarche de résolution ascendante, le programmeur part du cas
particulier du problème complexe à résoudre et l’enrichit progressivement jusqu’à résolution
du problème général.
Exemple : Factures d’électricité
Calculer le montant à payer de plusieurs factures d’électricité sachant que le taux de la TVA est
de 20% et le prix unitaire est de 0.6 DH pour la tranche inférieure à 100 KWh et 0.9 DH pour ce
qui est au delà .
Définition du problème
Entrées : L’ancien index ai et le nouvel index ni pour chaque facture.
sorties : La consommation, le prix hors taxe PHT et le prix TTC (PTTC) de chaque facture.
Traitement : Calculer la consommation, le prix hors taxe et le prix TTC de chaque facture.
Cas particuliers : ai > ni, ai < 0, ni < 0.
Planification
Traitement : Calculer la consommation, le prix hors taxe et le prix TTC d’une facture.
Généraliser le traitement à plusieurs factures. 38
 EXEMPLE DE LA DEMARCHE ASCENDANTE (2)
Version 1 de l'algorithme :
Début
1- Lire (ai,ni)
2- Calculer la consommation, le prix hors taxe et le prix TTC d’une facture.
3- Ecrire consommation
4- Ecrire PHT
5- Ecrire PTTC
6- Généraliser le traitement à plusieurs factures.
Fin
Développement avec la démarche ascendante
Version 2 de l'algorithme : Traitement d’une facture
Début
1- Lire (ai,ni)
2- Calculer la consommation
3- Calculer le prix hors taxe PHT
4- Calculer le prix TTC PTTC
5- Ecrire (consommation, PHT, PTTC)
Fin 39
 EXEMPLE DE LA DEMARCHE ASCENDANTE (3)
Version 3 de l'algorithme : Version 4 de l'algorithme : Introduire les cas
particuliers
Début
1- Lire (ai,ni) Début
2- consommation  ni - ai 1- Lire (ai,ni)
3- Si consommation ≤ 100 alors 2- Si ai > ni ou ai < 0 ou ni < 0 alors
4- PHT  consommation * 0.6 3- Ecrire ('Erreur de saisie')
5- Sinon 4- Sinon
6- PHT  (100 * 0.6) + (consommation – Début
100) * 0.9 5- consommation  ni - ai
7- PTTC  PHT * (1+0.2) 6- Si consommation ≤ 100 alors
8- Ecrire (consommation, PHT, PTTC) 7- PHT  consommation * 0.6
Fin 8- Sinon
9- PHT  (100 * 0.6) + (consommation – 100) * 0.9
10- PTTC  PHT * (1+0.2)
11- Ecrire (consommation, PHT, PTTC)
Fin
Fin 40
 EXEMPLE DE LA DEMARCHE ASCENDANTE (4)
Version 5 de l'algorithme : Généraliser à plusieurs factures
Début
1- Lire (ai,ni)
2- Si ai > ni ou ai < 0 ou ni < 0 alors
3- Ecrire ('Erreur de saisie')
4- Sinon
Début
5- consommation  ni - ai
6- Si consommation ≤ 100 alors
7- PHT  consommation * 0.6
8- Sinon
9- PHT  (100 * 0.6) + (consommation – 100) * 0.9
10- PTTC  PHT * (1+0.2)
11- Ecrire (consommation, PHT, PTTC)
Fin
12- S’il y a une nouvelle facture refaire le même traitement que précédemment
Fin 41
 EXEMPLE DE LA DEMARCHE ASCENDANTE (4)
Version 6 de l'algorithme :
Début
1- Faire
Début
2- Lire ai et ni
3- Si ai > ni ou ai < 0 ou ni < 0 alors
4- Ecrire ('Erreur de saisie')
5- Sinon
Début
6- consommation  ni - ai
7- Si consommation ≤ 100 alors
8- PHT  consommation * 0.6
9- Sinon
10- PHT  (100 * 0.6) + (consommation – 100) * 0.9
11- PTTC  PHT * (1+0.2)
12- Ecrire (consommation, PHT, PTTC)
Fin
13- Lire nouvelle_facture
Fin
14- Tant que nouvelle_facture = 'oui’
Fin 42
 EXEMPLE DE LA DEMARCHE ASCENDANTE (5)
Validation de l’algorithme
Trace de l'algorithme pour ai=100 et ni=170 et ensuite ai=100 et ni=250 :
Opération Ai ni cons PHT PTTC Nouvelle Facture
1 - - - - - -
2 100 170 - - - -
3 100 170 - - - -
5 100 170 - - - -
6 100 170 70 - - -
7 100 170 70 - - -
8 100 170 70 42 - -
11 100 170 70 42 50.4 -
12 100 170 70 42 50.4 -
13 100 170 70 42 50.4 Oui
14 100 170 70 42 50.4 Oui
2 100 250 70 42 50.4 Oui
3 100 250 70 42 50.4 Oui
5 100 250 70 42 50.4 Oui
6 100 250 150 42 50.4 Oui
7 100 250 150 42 50.4 Oui
9 100 250 150 42 50.4 Oui
10 100 250 150 90 50.4 Oui
11 100 250 150 90 108 Oui
12 100 250 150 90 108 Oui
13 100 250 150 90 108 Nom
14 100 250 150 90 108 Nom
43
 EXEMPLE DE LA DEMARCHE ASCENDANTE (4)
Validation par classes de valeurs d'entrées :
Cas où nouvelle facture=non, le programme s’arrête.
Cas où nouvelle facture=oui, le programme commence à calculer la facture
concernée.
Cas où ai < 0 ou ni < 0, le programme affiche un message d’erreur et demande s’il
y a ou non une nouvelle facture à traiter.
Cas où ai > ni, le programme affiche un message d’erreur et demande s’il y a ou
non une nouvelle facture à traiter.
Cas où ai ≤ ni, le programme calcule les résultats demandés, demande s’il y a
d’autres factures à traiter et relance le traitement si oui, sinon il s’arrête. Un jeu
d’essai aide à confirmer la pertinence des résultats obtenus.

44
CONCEPTS DE BASE DU LANGAGE C

45
INTRODUCTION
En 1970, Dennis RITCHIE a créé le langage C, un langage de haut niveau,
pour écrire le système d'exploitation Unix. La conception de ce langage
a été régie par les pré requis suivants :
• la souplesse
• la fiabilité
• la portabilité
• les possibilités de l'assembleur

46
 UN PREMIER PROGRAMME EN C
main( )
{
printf("bonjour la première année");
}

• main () indique qu'il s'agit du programme principal.

• { et } jouent le rôle de début et fin de programme.
• Printf est l'instruction d'affichage à l'écran, le message étant entre
guillemets.
• ; indique la fin d'une instruction.
Remarque :
Un programme en C doit contenir au moins le programme principal (la partie
main).
47
 Traduction en langage de programmation
Rappel
• Un langage de programmation permet au programmeur d'écrire son programme suivant une
grammaire qui peut être, soit celle du langage machine même, soit une grammaire
facilement interprétable par la machine ou pouvant être traduite en langage machine au
moyen d'un outil logiciel dit compilateur du langage.
• Il existe, en fait, trois catégories de langages :
• Le langage binaire : il s'agit du langage machine exprimé par des chiffres (0 ou 1). Ce langage
produit, en effet, des programmes automatiquement consommables (compréhensibles) par
la machine mais qui sont illisibles et non portables.
• Les langages de bas niveau (comme l'assembleur) : ces langages produisent des programmes
facilement interprétables par la machine mais d'utilisation lourde pour les programmeurs.
• Les langages évolués : ils sont, d'utilisation, souples et produisent des programmes clairs et
lisibles mais ils doivent encore être compilés (traduits en langage machine par un
compilateur du langage) pour générer des programmes exécutables. Nous en citons:
Fortran, Basic, Pascal, C, C++, Visual Basic, Visual C++, Java... 48
 Exemple: Programme en C
• Ce programme écrit en C calcule le montant de la facture de téléphone
#include <stdio.h>
main( )
{
int consommation, prix_d_abonnement ;
float prix_unitaire, TVA, PT ;
printf("Entrer la valeur de la consommation :");
scanf("%d",&consommation) ;
printf("Entrer la valeur du prix unitaire :");
scanf("%f",&prix_unitaire) ;
printf("Entrer la valeur de la TVA :");
scanf("%f",&TVA) ;
printf("Entrer la valeur du prix abonnement :");
scanf("%d",&prix_d_abonnement) ;
PHT=(consommation * prix_unitaire) + prix_d_abonnement ;
PT=PHT * (1+TVA) ;
printf("Le prix total est de %f DH\n",PT);
} 49
 COMPILATION ET EXECUTION D'UN
PROGRAMME EN C
• Le compilateur traduit le programme source en un fichier objet (qui porte
l'extension .o).
• L'éditeur de liens génère pour les différents fichiers objet composant le
programme un fichier exécutable.
• Exemple: compilateur gcc
Pour compiler et executer avec gcc un programme C portant le nom
helloWord.c on utilise les commandes suivantes:
- gcc -o hello helloWorld.c
- hello

50
 LES DIRECTIVES DE COMPILATION
Nous en citons les directives include et define:
Syntaxe :
#include < nom_fichier>
indique le fichier de bibliothèque C à inclure dans le programme. Ce fichier
contient les définitions de certaines fonctions prédéfinies utilisées dans le
programme.
Syntaxe :
#define expression_à_remplacer expression_de_remplacement
permet de remplacer un symbole par une constante ou un type ou de faire
des substitutions avec arguments dans le cas des macros.

Exemple:

#include <stdio.h> /*ce fichier contient les fonctions d'entrées/sorties comme printf*/
#define pi 3.14 /*pi sera remplacé par la valeur 3.14*/
#define entier int /*entier sera remplacé par le type prédéfini int*/
#define somme(x,y) x+y /*la macro somme(x,y) sera remplacée par x+y*/
51
LES COMMENTAIRES
Un commentaire est un texte placé entre les signes /* et */. Il permet
de commenter une ou plusieurs lignes de commandes en vue d'éclairer
le lecteur.
Syntaxe :
/* texte du commentaire */

Exemples :
main( )
{
printf("bonjour"); /* ce programme affiche bonjour*/
}

52
 DECLARATION DE VARIABLES
• A toute variable utilisée dans un programme C doivent être associés d'abord
(avant toute utilisation) un nom dit identificateur et un type de données
(entier, réel ou caractère…). Lors de l'exécution, une zone mémoire (dont la
taille dépend du type) sera réservée pour contenir la variable.
Syntaxe :
Type identificateur;
Ou
Type identificateur1, identificateur2, … ,identificateur n;

Exemples :

int i; /* i est une variable de type entier */

float j,k; /* j et k sont des variables de type réel */
char c; /* c est une variable de type caractère */
53
 Identificateurs
L'emploi des identificateurs doit répondre à un certain nombre d'exigences :
• un identificateur doit être composé indifféremment de lettres et chiffres ainsi que du
caractère de soulignement ( _ ) qui peut remplacer des espaces.
• Un identificateur doit commencer par une lettre ou le caractère de soulignement.
Néanmoins, celui-ci est souvent utilisé pour désigner des variables du système.
• Seuls les 32 premiers caractères (parfois, uniquement les 8 premiers) sont significatifs
(pris en compte par le compilateur).
• Majuscules et minuscules donnent lieu à des identificateurs différents.
• Un identificateur ne doit pas être un mot réservé (utilisé dans le langage C comme int,
char, … ).
Exemples :
solution1 est un identificateur valide (constitué de lettres et de 1)
1solution n'est pas un identificateur valide.
prix unitaire n'est pas un identificateur valide (Il contient un espace).
prix_unitaire est un identificateur valide.
jour, Jour et JOUR sont 3 identificateurs différents
int n'est pas un identificateur valide. C'est un mot utilisé en C 54
 Types de données
Un type est un ensemble de valeurs que peut prendre une variable. Il y a des types prédéfinis et des
types qui peuvent être définis par le programmeur.
Types simples prédéfinis en C
Type Signification Représentation système
Taille Valeurs limites
(bits)
int Entier 16 -32768 à 32767
short (ou short int) Entier 16 -32768 à 32767
long (ou long int) Entier en double longueur 32 -2147483648 à 2147483647
char Caractère 8
float (ou short float) Réel 32 ± 10-37 à ± 1038
double(ou long float) Réel en double précision 64 ± 10-307 à ± 10308
long double Réel en très grande précision 80 ± 10-4932 à ± 104932
unsigned Non signé (positif) 16 0 à 65535

Remarque: Exemple:
• int équivaut à short sur PC et à long sur station. - n=sizeof(int); /* n reçoit 2 */
55
• La fonction sizeof retourne la taille en octets d'un objet. - n=sizeof(3.14); /* n reçoit 8 */
 Fonctions prédéfinies sur les types simples
Des fonctions appliquées au différents types de données sont prédéfinies dans
des fichiers de bibliothèque C.
• Fonctions mathématiques
Math.h
Ce fichier contient des fonctions mathématiques pouvant être appliquées aux types
numériques.

Exemples :
#include <math.h> /*pour inclure le fichier math.h*/
main( )
{
int p,i=4,j=-2; /* p entier et i et j entiers initialisés à 4 et -2*/
float r; /* r réel*/
p=pow(i,2); /* p reçoit 16 (4 à la puissance 2) */
r=sqrt (i); /* r reçoit 2 (racine carrée de 4) */
i=abs(j); /* i reçoit 2 (valeur absolue de -2)*/
}
56
 Fonctions prédéfinies sur les types simples
• Fonctions sur les caractères
ctype.h
Ce fichier contient les définitions des fonctions pouvant être appliquées à des caractères.
Ces fonctions permettent de vérifier si un caractère appartient à une catégorie donnée. Elles
retournent 0 si faux et une valeur différente si vrai.
Listes des fonctions sur les caractères
Fonction Signification
isalpha (c) c est une lettre
isupper (c) c est une lettre majuscule
islower (c) c est une lettre minuscule
isdigit (c) c est un chiffre
isxdigit (c) c est hexadécimal [0-9], [A-F] ou [a-f]
isalnum (c) c est alphanumérique (chiffre ou lettre)
isspace (c) c est un blanc, tabulation, retour chariot, newline ou formfeed
ispunct (c) c est un caractère de ponctuation
isprint (c) c est un caractère imprimable (de 32 (040) à 126 (0176) tilde)

isgraph (c) c est un caractère imprimable différent d'espace

iscntrl (c) c est un caractère de contrôle différent d'espace et (<32) ou delete (0177)
isascii (c) c est un caractère ASCII (0 <= c < 128) 57
 DECLARATION DE CONSTANTES
Une constante est une donnée dont la valeur ne varie pas lors de l'exécution du
programme. Elle doit être déclarée sous forme :
Syntaxe :
const Type Identificateur = Valeur ;
Remarque:
Une valeur constante peut, également, être exprimée au moyen d’un
identificateur défini en utilisant la directive define:
#define Identificateur Valeur
Exemples : 1- main( )
{
const float pi=3.14; /*déclare la constante pi avec const*/
printf("pi égale à %f",pi); /*affiche la valeur de pi*/
}
2- #define pi 3.14 /*définit la constante pi avec define*/
main( )
{
printf("pi égale à %f",pi); /*affiche la valeur de pi*/
}
58
 INITIALISATION DE VARIABLES
Une valeur initiale peut être affectée à une variable dès la déclaration sous forme :
Syntaxe :
a) Cas de types numériques :
Type Identificateur = Valeur numérique ;
b) Cas du type caractère :
Type Identificateur = 'caractère' ;
Ou
Type Identificateur = code ASCII d'un caractère ;

Exemples : main( )
{
int i, j=3, k; /* seul j est initialisé à 3*/
float f=1.2 e5; /* f est initialisé à 120000 (1.2*105)*/
int i=011; /* i est initialisé à 11 en octal soit 9 en décimal*/
char c='A’; /* c est initialisé à la lettre A*/
char c=65; /* c est initialisé à A dont le code ASCII est 65*/
}

Remarque :
• Des caractères spéciaux sont représentés à l'aide du métacaractère \. 59
 L’AFFECTATION (ASSIGNATION)
L'affectation est l'opération qui attribue à une variable, au moyen de l'opérateur =, une valeur
constante ou résultat d'une expression. Syntaxe :
Variable = Valeur ou expression ;
Exemples : main( )
{
int i, j;
i=2; /*i reçoit 2*/
j=(i*3)+5; /*j reçoit 11 résultat de (2*3)+5*/
i=j=2; /*j reçoit d'abord 2 puis i reçoit la valeur de j (2)*/
Remarque : }

C permet de faire des assignations entre des variables de types différents. Des conversions de
types sont alors automatiquement réalisées.
1- main( )
Exemple: {
int i; /*i entier*/
float j=3.5; /*j réel initialisé à 3.5*/
i=j; /*i reçoit 3, le résultat est tronqué*/
}
2- main( )
{
int i; /*i entier*/
char c='A’; /*c caractère initialisé à A*/
i=c; /*i reçoit 65 le code ASCII de A*/
} 60
 L’AFFICHAGE(1)
L’instruction printf permet d'obtenir un affichage formaté à l'écran.
Syntaxe :
a) affichage de message constitué de texte et de caractères de contrôle
Printf ("texte et caractères de contrôle") ;
b) affichage de valeurs de variables ou d'expressions
Printf("message et formats d'affichage", arg1, arg2,…,argn);
argx: représente des noms de variables ou expressions

Exemples : main( )
{
int i=2,k=5; /*i et k entiers initialisés à 2 et 5*/
float j=3.5; /*j réel initialisé à 3.5*/
printf("Donnez le prix unitaire"); /*le programme affiche Donnez le prix unitaire */
printf("Donnez le prix unitaire \n"); /*le programme affiche Donnez le prix unitaire et retourne à la ligne (\n)*/
printf("la valeur de i est %d\n ",i); /*le programme affiche la valeur de i est 2 et retourne à la ligne*/
printf("i=%d j=%f",i,j); /*le programme affiche i=2 j=3.5*/
printf("i=%d\nj=%f",i,j); /*le programme affiche i=2
j=3.5*/
printf("somme(%d,%d)=%d\nFIN",i,k,i+k); /*le programme affiche
somme(2,5)=7
FIN*/
printf("j=%4.2f\n",j); /*le programme affiche
j= 3.50*/
}
61
 L’AFFICHAGE(2)
Remarques :
• Un caractère de contrôle est précédé de \ comme \n qui provoque un interligne (voir liste des caractères
spéciaux, paragraphe 2-4).
• Chaque format d'affichage est introduit par le caractère % suivi d’un caractère qui indique le type de
conversion.
• Des indications peuvent être rajoutées entre le % et le caractère comme le nombre minimum de
caractères réservés à l'affichage de la mantisse d’un nombre et le nombre de décimales.
Format d'affichage Signification
%d Conversion en décimal
%o octal
%x hexadécimal (0 à f)
%X hexadécimal (0 à F)
%u entier non signé
%c caractère
%s chaîne de caractères
%l long ou double
%L long double
%e sous forme m.nnnexx
%E sous forme m.nnnExx
%f sous forme mm.nn
%g Semblable à e ou f selon la valeur à afficher 62
 LA LECTURE DE DONNEES
L’instruction scanf effectue la lecture des variables.
Syntaxe :
scanf("formats d'affichage", variable1, variable2,…,variablen) ;
Remarque :
Seules les variables scalaires (entiers, réels et caractères) doivent être précédées de &.

Exemples :
#include <stdio.h>
main( )
{
int i; /*i entier*/
float k; /*k réel*/
char m; /* m caractère*/
scanf("%d",&i); /*le programme lit une valeur entière et l'affecte à i*/
scanf("%d%f",&i,&k); /*le programme lit une valeur entière de i
puis une valeur réelle de k*/
scanf("%c",&m); /*le programme lit un caractère et l'affecte à
la variable m*/
}

Remarques :
• La notation &variable est utilisée pour indiquer l'adresse mémoire de la variable en question.
• Les données tapées au clavier sont d'abord placées dans un tampon interne. Scanf va chercher ces données dans ce
tampon, sans nécessairement le vider entièrement. C’est pourquoi, la fonction scanf est malheureusement une source
permanente de problèmes (tampon associé au clavier encombré de résidus de lectures précédentes). Elle n'est, en
63
général, acceptable qu’à condition de se limiter à des lectures d'entiers ou de réels.
 LES OPERATEURS ARITHMETIQUES
Les opérateurs arithmétiques traditionnels sont :
+ addition
- soustraction
* multiplication
/ division
% reste de la division entière

Exemples :
main( )
{
int i=9,j=4,k; /*i, j et k entiers*/
float x=9.0, y; /*x et y réel*/
k=i+j; /*k reçoit 13*/
y=i/j; /*y reçoit 2.0 (division entière : i et j entiers)*/
y=x/j; /*y reçoit 2.25 (division réelle : x réel*/
y=9.0/j; /*y reçoit 2.25 (division réelle : 9.0 réel*/
k=i%j; /*k reçoit 1 (reste de la division de i par j)*/
}

Remarques :
• l'opérateur / effectue, en fonction du type des opérandes, une division entière (euclidienne) ou réelle.
• L'ordre des priorités des opérateurs est important.
• Il est possible de forcer la conversion du type d'une variable ou d’une expression en les préfixant d'un
type au choix. 64
 LES OPERATEURS +=, -=, *=, /=

Ils sont utilisés pour faciliter l'écriture.

Ecriture classique Ecriture équivalente
i = i + 20; i += 20;
i = i - 20; i -= 20;
i = i * 20; i *= 20;
i = i / 20; i /= 20;

65
 LES OPERATEURS LOGIQUES
Les opérateurs logiques sont, par ordre décroissant de priorité :
Opérateurs signification
! Non logique
> >= < <= Test de supériorité et d'infériorité
== et != Test d'égalité et d'inégalité
&& et || ET et OU logique

Exemples :
#include <stdio.h>
main( )
{
int a,b,c; /*a,b et c entiers*/
printf ("Introduire a, b et c : ");
scanf ("%d%d%d",&a,&b,&c);
if (a==b && b!=c) /*si a=b et bc affiche le message suivant*/
printf("a égale à b et b différent de c\n");
if (!(a<b) || a==0) /*si a>=b ou a=0 affiche le message suivant*/
printf("a est supérieure ou égale à b ou a égale à 0\n");
}

Remarques :
Soit i une variable numérique,
• l'expression if (i) est équivalente à l'expression if (i!=0).
66
• l'expression if (!i) est équivalente à l'expression if (i==0).
 LES OPERATEURS ++ ET --
Ils permettent d'incrémenter ou de décrémenter une variable. L'opérateur ++ (--)
effectue une pré-incrémentation (pré-décrémentation) ou une post-
incrémentation (postdécrémentation) selon son emplacement après ou avant la
variable. Dans une opération d'affectation qui met en jeu l'opérateur de :
• pré-incrémentation (pré-décrémentation), la variable est d'abord incrémentée
(décrémentée) de 1. L'affectation est ensuite effectuée.
• post-incrémentation (post-décrémentation), L'affectation (sans les ++ (--)) est effectuée
avant l'incrémentation (décrémentation).
Exemples : Instruction Equivalent Résultats
i++; i=i+1; i=4
Soient i=3 et j=5, ++i; i=i+1; i=4
i--; i=i-1; i=2
--i; i=i-1; i=2
i= ++j; j=j+1; i=j; j=6 et i=6
j= ++i + 5; i=i+1; j=i+5; i=4 et j=9
j= i++ + 5; j=i+5; i=i+1; j=8 et i=4;
67
 LES OPERATEURS DE TRAITEMENT DE BITS
Rappel : (opérations logiques)

1&1=1 1|1=1 1^1=0

1&0=0 1|0=1 1^0=1
0&1=0 0|1=1 0^1=1
0&0=0 0|0=0 0^0=0

Les opérateurs de traitement de bits en C s'appliquent uniquement à des entiers

ou des caractères. Ils ne s'appliquent, donc, pas à des opérandes réels (de type
float ou double). Opérateur Traitement
& et binaire
| ou binaire
^ ou exclusif
<< décalage à gauche
>> décalage à droite
68
~ complément à 1
 L’INSTRUCTION SI (IF) (1)
L'instruction if sélectionne le traitement (bloc d'instructions) à faire si une
condition est vérifiée. Syntaxe :
if (condition)
{
instruction1;
instruction2;
… Traitement
instructionn;
}
Exemples :
#include <stdio.h>
main( )
{
int a,b; /*a et b entiers*/
printf ("Introduire a et b : ");
scanf ("%d%d",&a,&b);
if (a==0) /*si a=0 affiche les messages zéro puis FIN*/
{
printf("zéro\n");
printf("FIN\n");
}
if (a==1) /*si a=1 affiche le message un*/
printf("un\n");
if (a=b) /*faire a=b; puis if (a) [si a0] affiche le message suivant*/
{
printf("a est différent de 0\n");
} 69
}
 L’INSTRUCTION SI (IF) (2)
Remarque :
• Si le traitement à effectuer est constitué d'une seule instruction, il est possible d'omettre
les accolades.
Lorsque if est utilisée avec else, elle indique également le traitement à faire si la
condition n'est pas vérifiée.
Syntaxe :
if (Condition)
{ Exemples :
instruction1; #include <stdio.h>
instruction2; main( )
Traitement1 {
… int a,b; /*a et b entiers*/
instructionn; printf ("Introduire a et b : ");
} scanf ("%d%d",&a,&b);
else if (a==b) /*si a=b affiche a égale à b sinon
{ affiche a différent de b */
instruction1'; printf("a égale à b\n");
instruction2’; else
Traitement2 printf("a différent de b\n");
… }
instructionn’;
} 70
 L’INSTRUCTION SI (IF) (3)
Remarque:
Dans une imbrication, else se rapporte toujours à if le plus rapproché (le plus
interne).
Exemples :
#include <stdio.h>
main( )
{
int a,b,z,n; /*a, b,z et n entiers*/
printf ("Introduire a, b et n : ");
scanf ("%d%d%d",&a,&b,&n);
if (n>0)
if (a>b) /*si n>0 et a>b*/
z=a;
else /*si n>0 et a<=b (else se rapporte à if (a>b))*/
z=b;
if (n>0)
{
if (a>b) /*si n>0 et a>b*/
z=a;
}
else /*si n<=0 (else se rapporte à if (n>0))*/
z=b;
}
71
 L’INSTRUCTION SWITCH (1)
Elle réalise un aiguillage vers différentes instructions en fonction du contenu d’une
variable de contrôle.
Le sélecteur de switch (la variable de contrôle) doit être un entier ou un caractère.
Syntaxe :
switch (Variable de contrôle)
{
case Valeur1 : Traitement1 (bloc d'instructions)
break;
case Valeur2 : Traitement2
break;
…
case Valeurn : Traitementn
break;
default : Traitementm
}

Remarque : Valeuri est une constante. 72

 L’INSTRUCTION SWITCH(2)
Exemples :
#include <stdio.h>
main( )
{
int a; /*a entier*/
char c; /*c char*/
printf ("Introduire un nombre et une lettre: ");
scanf ("%d%c",&a,&c);
switch (a) /*le programme traite tous les cas de a (0,1 ou autres)*/
{
case 0 : printf ("Le nombre introduit est zéro\n");
break;
case 1 : printf ("Le nombre introduit est 1\n");
break;
default : printf ("Le nombre introduit est différent de 0 et 1\n");
}
switch (c) /*Ici, on traite uniquement les cas où c égale à x ou y*/
{
case 'x’ : printf ("La lettre saisie est la lettre x\n");
break;
case 'y’ : printf ("La lettre saisie est la lettre y\n");
break;
}
}
Remarque :
• L'instruction break fait sortir de switch. 73
 L’INSTRUCTION TANT QUE (WHILE)
L'instruction while permet de répéter un traitement autant de fois qu'une condition est vérifiée. Les instructions en question sont alors
exécutées tant que la condition est vraie.

Syntaxe :
while (Condition)
{
Traitement (bloc d'instructions qui se terminent par ;)
}
fonctionnement :
Le système teste d'abord si la condition est vraie; si oui, exécute le traitement et remonte automatiquement à la ligne
Exemples: while pour tester de nouveau la condition. Elle s'arrête quant la condition devient fausse.

#include <stdio.h>
main( )
{
int n,somme=0; /*n entier et somme entier initialisé à 0*/
printf("Introduire n : " );
scanf("%d",&n);
while (n>0) /*tant que n>0, le programme rajoute n à la somme obtenue puis décrémente n*/
{
s=s+n;
n--;
}
printf ("%d",somme); /*le programme affiche la somme des nombres compris entre 0 et n*/
}
Remarque : Lors de l'utilisation de l'instruction while, à chaque itération, la condition est évaluée en premier, avant
74
l'exécution du traitement.
 L’INSTRUCTION FAIRE TANT QUE (DO WHILE)
L'instruction do while permet de répéter un traitement jusqu'à ce qu'une
condition ne soit plus vérifiée. Elle joue le même rôle que while. Néanmoins, Lors
de l'utilisation de l'instruction while, à chaque itération (fois), le traitement est
exécuté en premier, avant que la condition ne soit évaluée.

Syntaxe :
do
{
Traitement (bloc d'instructions qui se terminent par ;)
}
while (Condition) ;
fonctionnement :
Le système exécute d'abord le traitement puis teste si la condition est vraie; si oui, il remonte
automatiquement à la ligne do pour exécuter de nouveau le traitement. Il s'arrête quant la condition
devient fausse.

75
 L’INSTRUCTION FAIRE TANT QUE (DO
WHILE)
Exemples:
#include <stdio.h>
main( )
{
int n, somme=0, i=0; /*n entier et somme et i entiers initialisés à 0*/
printf("Introduire n : " );
scanf("%d",&n);
do /*le programme rajoute i à somme puis l'incrémente tant que i ≤ n*/
{
somme=somme+i
i++;
}
while (i<=n) ;
printf ("%d",somme); /*le programme affiche la somme des nombres compris entre 0 et n*/
}

Remarque :
• Lors de l'utilisation de l'instruction do while, le traitement sera exécuté au moins une fois quelle
que soit la condition. 76
 L’INSTRUCTION FAIRE TANT QUE (DO
WHILE)
Exemple: Instructions while et do while

#include <stdio.h>
main( )
{
int i=3; /*i entier initialisé à 3*/
do
{
printf ("%d",i);
i++;
}
while (i<3) ; /*avec do while, i (3) sera affiché même si la condition i<3 est fausse au début*/
i=3; /*remet i à 3*/
while (i<3) /*avec while, rien n'est affiché car la condition i < 3 est fausse*/
{
printf ("%d",i);
i++;
}
}
77
 L’INSTRUCTION POUR (FOR)
L'instruction for permet de répéter un traitement donné un nombre de fois précis.
Syntaxe :
for (Initialisations;Condition;Instructions)
{
Traitement (bloc d'instructions qui se terminent par ;)
}
fonctionnement :
for commence au départ, par effectuer les initialisations (en premier argument), exécute le traitement tant que la condition (en deuxième
argument) est vérifiée et exécute les instructions (en troisième argument) à chaque fin d'itération.

Exemples:
#include <stdio.h>
main( )
{
int i,j,n,somme=0; /*i, j, n entiers et somme entier initialisée à 0*/
printf("Introduire n : " );
scanf("%d",&n);
for (i=1; i<=n; i++) /*pour i allant de 1 à n, le programme rajoute i à somme*/
somme=somme+i ;
printf ("%d",somme); /*le programme affiche la somme des valeurs comprises entre 0 et n*/
for (i=2, j=4; i<5 && j>2; i++, j--) /*pour i allant de 2 à 4 et j de 4 à 3, le programme affichera i et j si i<5 et j>2*/
printf ("i:%d et j:%d\n",i,j);
/*Cette boucle affichera donc i:2 et j:4 i:3 et j:3*/
78
}
 LES INSTRUCTIONS DE SORTIES DE BOUCLES (BREAK ET
CONTINUE)
Break permet de sortir directement de la boucle (for, while ou do while) la plus
interne.
Continue permet de passer directement à l'itération suivante de la boucle la plus
interne.
Exemple:
#include <stdio.h>
main( )
{
int i; /*i entier*/
for (i=5; i>0; i--) /*pour i allant de 5 à 1*/
{
if (i==5) continue; /*arrête l'exécution de l'itération1 et passe à l'itération2*/
printf ("Ok");
if (i==4) break; /*arrête l'exécution à l'itération2 (sort de for)*/
} /*le programme affichera donc une fois OK*/
}
79
 L’INSTRUCTION ALLER A (GOTO)
L'instruction goto permet de brancher (inconditionnellement) à une ligne du programme.
Celle-ci doit avoir été étiquetée (précédée d'une étiquette constituée d'un identificateur suivi
de :). Syntaxe :
goto Etiquette ;
fonctionnement :
Le système interrompt l'exécution séquentielle du programme, remonte ou descend à la ligne appelée étiquette et poursuit
l'exécution à partir de celle-ci.

Exemple: #include <stdio.h>

main( )
{
int i=0; /*i entier initialisé à 0*/
printf("%d",i); /*affiche 0*/
goto message; /*saute à l'étiquette message*/
i++; /*ne sera alors pas exécuté*/
printf("%d",i); /*ne sera alors pas exécuté*/
message : printf("OK\n"); /*affiche OK*/
printf("FIN\n"); /*affiche FIN*/
} /*le programme affichera donc 0, OK et FIN*/
Remarque :
• Goto a la réputation de rendre les programmes moins lisibles. Néanmoins, son
utilisation est importante dans des cas qui l'impose. 80
LES TABLEAUX

81
 Introduction
Un tableau est une collection homogène de données, ordonnée et de taille
statique. Il fut un ensemble d'octets permettant de représenter une liste
d'éléments de même type. Chaque élément est repéré par un indice (son rang
dans le tableau).
Exemple :
Indices 0 1 2 3 4 5 6
15 20 25 30 100 200 150
Tableau t

15 est l'élément d'indice 0, il est noté en C par t[0].

100 est l'élément d'indice 4, il est noté en C par t[4].

82
 TABLEAUX A UNE DIMENSION
(VECTEURS)/DECLARATION
Syntaxe :
Type Identificateur [Taille constante] ;
La Taille du tableau est le nombre de ses éléments. Elle ne peut être une variable. Elle doit être
une constante définie avant ou au moment de la déclaration.

Exemple:
#include <stdio.h>
#define taille1 5 /*taille1: constante de valeur 5*/
#define taille2 3 /*taille2: constante de valeur 3*/
main( )
{
int a [taille1]; /*a: tableau de 5 entiers*/
a[0]=15; /*la première case du tableau a reçoit 15*/
char b [taille2]; /*b: tableau de 3 caractères*/
b[0]='x’; /*la première case du tableau b reçoit la lettre x*/
b[1]='y’; /*la deuxième case du tableau b reçoit la lettre y*/
float c [10]; /*c: tableau de 10 réels*/
scanf("%f", &c[0]); /*lit un réel et l'affecte à la première case de c*/
}
Remarque:
Les indices d'un tableau sont des entiers commençant à 0. 83
 REPRESENTATION PHYSIQUE
Lors de la déclaration d'un tableau, une zone mémoire lui sera réservée. Elle sera utilisée pour le stockage de ses
données. La taille de cette zone en octets est la multiplication de la taille du tableau par la taille du type de ses
éléments (un tableau de trois entiers sera représenté par six octets : chaque entier est codé sur deux octets).
Un tableau T correspond à l'adresse mémoire de son premier élément (T=&T[0]). Il s'agit de la première cellule de
la zone mémoire qui lui est réservé.
Représentation physique d'un tableau
#define taille 3 /*taille: constante de valeur 3*/
main( )
{
char T [taille]; /*T : tableau de 3 caractères : a, b et c*/
T[0]='a';
T[1]='b';
T[2]='c';
}

Contenu de la mémoire
Supposant que T a été mémorisé à l'adresse mémoire 100, un caractère étant codé sur un octet, le contenu
des cellules mémoire sera alors comme suit :
T=&T[0]=100
adresse 100 T[0]=‘a’
a &T[0] est 100

adresse 101 b
T[1]=‘b’ &T[1] est 101
c 84
adresse 102 T[2]=‘c’ &T[2] est 102
 INITIALISATION
Syntaxe :
Type Identificateur [Taille constante] = {Valeur1, Valeur2,…,Valeurn};

Exemples:
#include <stdio.h>
#define taille1 3 /*taille1: constante de valeur 3*/
main( )
{
float a [taille1]={0.,1.5,3.}; /*a: tableau de 3 réels initialisés à 0 , 1.5 et 3*/
int b [taille1]={1}; /*seul le premier élément du tableau b est initialisé à 1*/
char c [taille1]={'x', ,'y’}; /*seuls le 1er et 3ème éléments de c sont initialisés (à x et y)*/
int d [ ]={4,6,8}; /*d: tableau de 3 entiers initialisés à 4 , 6 et 8*/
}

Remarque :
• Un tableau peut être totalement ou partiellement initialisé. 85
 LECTURE ET AFFICHAGE
Les éléments d'un tableau sont à lire et à afficher élément par élément.
Exemple:
#include <stdio.h>
#define taille 20 /*taille: constante de valeur 20*/
main( )
{
int i, t [taille]; /*t: tableau de 20 entiers*/
for(i=0;i<taille;i++) /*lit les 20 entiers élément par élément*/
scanf ("%d",&t[i]);
for(i=0;i<taille;i++) /*affiche les 20 entiers élément par élément*/
printf ("%d\n",t[i]);
}

Remarque :
• Lors de la lecture ou de l'affichage d'un tableau, le compilateur C n'empêche pas un
dépassement des limites (la taille) du tableau. Une vérification par le programmeur est alors
importante. 86
 AFFECTATION
L'affectation de valeurs aux éléments d'un tableau se fait également individuellement
(comme pour la lecture et l'affichage).
Exemple:
#include <stdio.h>
#define taille 20 /*taille: constante de valeur 20*/
main( )
{
int i, t [taille]; /*t: tableau de 20 entiers*/
for(i=0;i<taille;i++) /*affecte i à chaque élément d'indice i*/
t[i]=i;
}

Remarques :
• L'affectation d'un tableau B à un autre tableau A se fait élément par élément. Une affectation
"brutale" de B à A (A=B) n'est pas possible.
• L'affectation élément par élément d'un tableau B à un autre tableau A (A[i]=B[i]) réalise une
copie de B dans A. 87
 COMPARAISON DE DEUX TABLEAUX
La comparaison des éléments de deux tableaux doit se faire élément par élément.
Exemple:
#include <stdio.h>
#define taille 20 /*taille: constante de valeur 20*/
main( )
{
char a [taille], b[taille]; /*a et b: tableaux de 20 caractères*/
int i, egaux; /*egaux entier utilisé comme variable logique égale à vrai (1) ou faux (0)*/
for(i=0;i<taille;i++) /*lit les éléments de a et b*/
{
scanf ("%c",&a[i]);
scanf ("%c",&b[i]);
}
egaux=1; /*on suppose que a et b sont égaux*/
for(i=0;i<taille;i++) /*compare les caractères un par un*/
if (a[i]!=b[i]) /*si un élément est différent de son correspondant,*/
{égaux=0; break;} /*on arrête la comparaison et on déduit que a et b ne sont pas égaux*/
if (egaux) /*si egaux est vrai (1)*/
printf ("a et b contiennent le même mot\n");
else /*si egaux est faux (0)*/
printf ("a et b contiennent des mots différents\n");
} 88
 CHAINES DE CARACTERES/INITIALISATION
Une chaîne de caractères est un tableau de caractères. Elle représente un cas
particulier des tableaux qui bénéficie de certains traitements particuliers en
plus de ceux réservés aux tableaux en général. Une chaîne de caractères peut
également être déclarée comme pointeur sur char (voir le chapitre pointeurs).
Syntaxe :
char Identificateur [Taille constante] = "Texte\0" ;
Le caractère '\0' indique la fin de la chaîne de caractères. Il est conseillé de ne pas l'omettre.

Exemples:
#define taille1 3 /*taille1: constante de valeur 3*/
#define taille2 4 /*taille2: constante de valeur 4*/
main( )
{
char t [taille1]="ali"; /*t chaîne de caractères initialisée au mot ali*/
char a [taille2]="ali\0"; /*a chaîne de caractères initialisée au mot ali et
terminée par le caractère '\0'*/
89
}
 LECTURE ET AFFICHAGE
Une variable de type chaîne de caractères peut être lue et affichée caractère par caractère au
moyen de scanf et printf utilisant le format %c.
Elle peut également être lue (affichée) globalement (d'un seul coup) au moyen de la fonction
scanf (printf) utilisant cette fois-ci le format %s ou au moyen de la fonction gets (puts).
Syntaxe :
scanf("%s", Chaîne de caractères);
printf("%s", Chaîne de caractères);
gets(Chaîne de caractères);
puts(Chaîne de caractères);
• scanf amène uniquement le texte introduit avant le premier blanc (espace) dans la variable à lire.
• gets amène tout le texte introduit jusqu'au retour chariot (retour à la ligne) dans la variable à lire.
Exemple:
/*Soit Turbo C la chaîne de caractères que l'on introduit lors de l'exécution de l'exemple suivant*/
#include <stdio.h>
#define taille 20 /*taille : constante de valeur 20*/
main( )
{
char t [taille]; /*t : chaîne de caractères de taille 20*/
scanf ("%s",t); /*lit t (on ne met pas d'adresse &)*/
printf ("%s",t); /*affiche Turbo*/
gets (t); /*lit t (on ne met pas d'adresse &)*/
puts (t); /*affiche Turbo C*/
} 90
 FONCTIONS SUR LES CHAINES DE CARACTERES
Des fonctions prédéfinies appliquées aux chaînes de caractères sont définies dans le fichier "string.h". Nous
en citons :
fonction Appliquée à retourne rôle
strlen Une chaîne de caractères Un entier Retourne la longueur d'une chaîne de caractères.
strcmp Deux chaînes de caractères Un entier Compare deux chaînes et retourne 0 si elles sont
égales, une valeur différente sinon.
strcpy Deux chaînes de caractères Rien (void) Copie une chaîne en deuxième argument dans une
autre en premier argument.

Exemples:
#include <string.h>
#define taille 20 /*taille : constante de valeur 20*/
main( )
{
char a [taille], b[taille]="ali\0"; /*a et b chaînes de caractères; b initialisée à "ali\0"*/
int n; /*n entier*/
n=strlen(b); /*n reçoit 3 (longueur du mot "ali")*/
strcpy(a,b); /*a reçoit la chaîne "ali\0"(copie de b)*/
n=strcmp(a,b); /*n reçoit 0 (résultat de la comparaison de a et b)*/
}
Remarque:
Les fonctions du fichier "string.h" ne peuvent être appliquées à des caractères de type char. Elles sont
appliquées à des chaînes de caractères (tableaux de caractères) qui se terminent par '\0' (On ne peut alors
comparer, par exemple, deux caractères a='x' et b='y' au moyen de strcmp). 91
 TABLEAUX A PLUSIEURS DIMENSIONS/ DECLARATION
Syntaxe :
Type Identificateur [Taille1] [Taille2] … [Taille n] ;
• Taillei est la taille de la dimension i. Elle doit être une constante définie avant ou au moment de la
déclaration.
• Un élément d'un tableau t à n dimensions est repéré par ses indices, sous forme t[i1][i2]…[in].

Exemples:
Déclaration et lecture d'un tableau à deux dimensions
/*Ce programme lit le nombre de buts marqués par chacun des 11 joueurs de 8 équipes*/
#include <stdio.h>
#define taille1 8 /*taille1: constante de valeur 8*/
#define taille2 11 /*taille2: constante de valeur 11*/
main( )
{
int t [taille1][taille2]; /*t : matrice de 8 lignes, 11 colonnes*/
int i, j;
for(i=0;i<taille1;i++) /*lit les éléments de t ligne par ligne*/
for (j=0; j<taille2;j++)
scanf ("%d",&t[i][j]);
}
92
 INITIALISATION
Syntaxe :
Type Identificateur [m] … [p] = { Liste0, … , Listem-1} ;
• Listei est l'initialisation de l'élément d'indice i et qui fut un sous tableau de dimension n-1 si n est la
dimension du tableau en question.

Exemple:
Le programme ci-dessous initialise la matrice M (3 lignes, 2 colonnes) :
0 1
M 2 3
4 5

Exemple:
#define taille1 3 /*taille1: constante de valeur 3*/
#define taille2 2 /*taille2: constante de valeur 2*/
main( )
{
int M [taille1][taille2]={{0,1},{2,3},{4,5}}; /*initialisation ligne par ligne*/
93
} /*M[0]={0,1}, M[1]={2,3} et M[2]={4,5}*/