Algo Et C

Cours d’Informatique
Département de Génie Electrique,

ENSAM Casablanca
Université Hassan II
Sige.ensam@gmail.com
Mohamed.hamlich@univh2c.ma
1
Objectif et plan du cours
 Objectif:
• Apprendre les concepts de base de l'algorithmique et de la
programmation
• Etre capable de mettre en oeuvre ces concepts pour analyser des

problèmes simples et écrire les programmes correspondants
 Plan:
• Généralités (matériel d’un ordinateur, systèmes d’exploitation, langages
de programmation, …)
• Algorithmique (affectation, instructions conditionnelles, instructions

itératives, fonctions, procédures, …)
• Langage C
2
Informatique?
 Techniques du traitement automatique de l’information au
moyen des ordinateurs
 Eléments d’un système informatique
Applications
(Word, Excel, Jeux, Maple, etc.)
Langages
(Java,C/C++, Fortran,etc.)
Système d’exploitation
(DOS,Windows, Unix, etc.)
Matériel
(PC, Macintosh, station SUN, etc.)
3
L’ordinateur
1. Ecran
2. Carte mère
3. Processeur
4. Mémoire vive (RAM)
5. Cartes (graphique, son,
réseau, …)
6. Alimentation
7. Lecteur/graveur CD/DVD
8. Disque Dur
9. Souris
10. Clavier
4
Définition et architecture (1)
« Un ordinateur est une machine servant à traiter des données. »
Périphériques Périphériques
d’entrées de sorties
BUS
Mémoire
Processeur
5
Définition et architecture (2)
 Le processeur : traite les données en exécutant un
programme.
 La mémoire : stocke les données et les programmes.
 Les périphériques d’entrée : permettent d’acquérir des

données de l’extérieur (ex : clavier, souris).
 Les périphériques de sortie : permettent de restituer des

données à l’extérieure (ex : écran, imprimante).
 Les bus : sont le média de communication.
6
Matériel: Principaux éléments d’un PC
 Unité centrale (le boîtier)

• Processeur ou CPU (Central Processing Unit)
• Mémoire centrale
• Disque dur, lecteur disquettes, lecteur CD-ROM
• Cartes spécialisées (cartes vidéo, réseau, ...)
• Interfaces d'entrée-sortie (Ports série/parallèle, …)
 Périphériques
• Moniteur (l'écran), clavier, souris
• Modem, imprimante, scanner, …
7
L’OS
 Les Systèmes d’Exploitation (ou Operating

System) sont une catégorie particulière de
logiciel.
• Programme central de l’ordinateur
• Responsable de la liaison entre les ressources

matérielles d’un ordinateur et les applications
informatiques de l’utilisateur (traitement de texte, jeu
vidéo…)
• Exemples : Windows, Linux
8
Qu’est ce qu’un système d’exploitation?
 Ensemble de programmes qui gèrent le matériel et
contrôlent les applications
• Gestion des périphériques (affichage à l'écran, lecture du

clavier, pilotage d’une imprimante, …)
• Gestion des utilisateurs et de leurs données (comptes,

partage des ressources, gestion des fichiers et répertoires, …)
• Interface avec l’utilisateur (textuelle ou graphique):

Interprétation des commandes
• Contrôle des programmes (découpage en taches, partage

du temps processeur, …)
9
Langages informatiques
 Un langage informatique est un outil permettant de
donner des ordres (instructions) à la machine
• A chaque instruction correspond une action du processeur
 Intérêt : écrire des programmes (suite consécutive

d’instructions) déstinés à effectuer une tache donnée
• Exemple: un programme de gestion de comptes bancaires
 Contrainte: être compréhensible par la machine
10
Langage machine
 Langage binaire: l’information est exprimée et manipulée sous
forme d’une suite de bits
 Un bit (binary digit) = 0 ou 1 (2 états électriques)
 Une combinaison de 8 bits= 1 Octet  28 256 possibilités qui permettent

de coder tous les caractères alphabétiques, numériques, et symboles tels que ?,*,&, …
• Le code ASCII (American Standard Code for Information Interchange) donne les
correspondances entre les caractères alphanumériques et leurs
représentation binaire, Ex. A= 01000001, ?=00111111
 Les opérations logiques et arithmétiques de base (addition,

multiplication, … ) sont effectuées en binaire
11
L'assembleur
 Problème: le langage machine est difficile à comprendre par l'humain
 Idée: trouver un langage compréhensible par l'homme qui sera

ensuite converti en langage machine
• Assembleur (1er langage): exprimer les instructions élémentaires
de façon symbolique
ADD A, 4
traducteur langage machine
LOAD B
MOV A, OUT
…
• +: déjà plus accessible que le langage machine
• -: dépend du type de la machine (n’est pas portable)
• -: pas assez efficace pour développer des applications complexes
 Apparition des langages évolués

12
Langages haut niveau
 Intérêts multiples pour le haut niveau:
• proche du langage humain «anglais» (compréhensible)
• permet une plus grande portabilité (indépendant du matériel)
• Manipulation de données et d’expressions complexes (réels,
objets, a*b/c, …)
 Nécessité d’un traducteur (compilateur/interpréteur),
exécution plus ou moins lente selon le traducteur
Code source Compilateur ou

Langage machine
en langage évolué interpréteur
13
Compilateur/interpréteur
 Compilateur: traduire le programme entier une fois pour toutes
Compilateur exécution
exemple.c exemple
fichier source fichier exécutable
• + plus rapide à l’exécution
• + sécurité du code source
• - il faut recompiler à chaque modification
 Interpréteur: traduire au fur et à mesure les instructions du

programme à chaque exécution
Interprétation+exécution
exemple.bas
fichier source
• + exécution instantanée appréciable pour les débutants
• - exécution lente par rapport à la compilation
14
Langages de programmation:
 Deux types de langages:

• Langages procéduraux
• Langages orientés objets
 Exemples de langages:
• Fortran, Cobol, Pascal, C, …
• C++, Java, …
 Choix d’un langage?
15
Etapes de réalisation d’un programme
Enoncé du problème
Spécification
Cahier des charges
Analyse
Algorithme
Traduction en langage
Programme source
Compilation
Programme exécutable
Tests et modifications
Version finale et résultats
La réalisation de programmes passe par l’écriture d’algorithmes

 D’où l’intérêt de l’Algorithmique
16
Du problème à la solution
Cahier des
charges
Analyse
Algorithme(s)
Programmation
Bibliothèques de fonctions
Programme(s)
Code fonction i
…
Code fonction j
Compilation
Code objet /
machine
Programme
exécutable
(logiciel) Édition de liens
17
Algorithmique
 Le terme algorithme vient du nom du mathématicien arabe
Al-Khawarizmi (820 après J.C.)
 Un algorithme est une description complète et détaillée des actions à

effectuer et de leur séquencement pour arriver à un résultat donné
• Intérêt: séparation analyse/codage (pas de préoccupation de syntaxe)

• Qualités: exact (fournit le résultat souhaité), efficace (temps d’exécution,
mémoire occupée), clair (compréhensible), général (traite le plus grand
nombre de cas possibles), …
 L’algorithmique désigne aussi la discipline qui étudie les algorithmes

et leurs applications en Informatique
 Une bonne connaissance de l’algorithmique permet d’écrire des

algorithmes exacts et efficaces
18
Représentation d’un algorithme
Historiquement, deux façons pour représenter un algorithme:
• L’Organigramme: représentation graphique avec des symboles
(carrés, losanges, etc.)
• offre une vue d’ensemble de l’algorithme
• représentation quasiment abandonnée aujourd’hui
• Le pseudo-code: représentation textuelle avec une série de

conventions ressemblant à un langage de programmation (sans
les problèmes de syntaxe)
• plus pratique pour écrire un algorithme
• représentation largement utilisée
19
Algorithmique
Notions et instructions de base
20
Notion de variable
 Dans les langages de programmation une variable sert à stocker
la valeur d’une donnée
 Une variable désigne en fait un emplacement mémoire dont

le contenu peut changer au cours d’un programme (d’où le nom
variable)
 Règle : Les variables doivent être déclarées avant d’être

utilisées, elle doivent être caractérisées par :
• un nom (Identificateur)
• un type (entier, réel, caractère, chaîne de caractères, …)
21
Choix des identificateurs (1)
Le choix des noms de variables est soumis à quelques règles qui
varient selon le langage, mais en général:
 Un nom doit commencer par une lettre alphabétique
exemple valide: A1 exemple invalide: 1A
 doit être constitué uniquement de lettres, de chiffres et du

soulignement _ (Eviter les caractères de ponctuation et les espaces)
valides: SMIP2007, SMP_2007 invalides: SMP 2005,SMI-2007,SMP;2007
 doit être différent des mots réservés du langage (par exemple en

Java: int, float, else, switch, case, default, for, main, return, …)
 La longueur du nom doit être inférieure à la taille maximale spécifiée

par le langage utilisé
22
Choix des identificateurs (2)
Conseil: pour la lisibilité du code choisir des noms significatifs
qui décrivent les données manipulées
exemples: TotalVentes2004, Prix_TTC, Prix_HT
Remarque: en pseudo-code algorithmique, on va respecter

les règles citées, même si on est libre dans la
syntaxe
23
Types des variables
Le type d’une variable détermine l’ensemble des valeurs qu’elle peut
prendre, les types offerts par la plus part des langages sont:
 Type numérique (entier ou réel)
• Byte (codé sur 1octet): de 0 à 255
• Entier court (codé sur 2 octets) : -32 768 à 32 767
• Entier long (codé sur 4 ou 8 octets)
• Réel simple précision (codé sur 4 octets)
• Réel double précision (codé sur 8 octets)
 Type logique ou booléen: deux valeurs VRAI ou FAUX
 Type caractère: lettres majuscules, minuscules, chiffres, symboles, …

exemples: ’A’, ’a’, ’1’, ’?’, …
 Type chaîne de caractère: toute suite de caractères,
exemples: " Nom, Prénom", "code postale: 1000", …
24
Déclaration des variables
 Rappel: toute variable utilisée dans un programme doit avoir
fait l’objet d’une déclaration préalable
 En pseudo-code, on va adopter la forme suivante pour la
déclaration de variables
Variables liste d'identificateurs : type
 Exemple:
Variables i, j,k : entier
x, y : réel
OK: booléen
ch1, ch2 : chaîne de caractères
 Remarque: pour le type numérique on va se limiter aux entiers

et réels sans considérer les sous types
25
L’instruction d’affectation
 l’affectation consiste à attribuer une valeur à une variable
(ça consiste en fait à remplir où à modifier le contenu d'une zone mémoire)
 En pseudo-code, l'affectation se note avec le signe ←

Var← e: attribue la valeur de e à la variable Var
- e peut être une valeur, une autre variable ou une expression
- Var et e doivent être de même type ou de types compatibles
- l’affectation ne modifie que ce qui est à gauche de la flèche
 Ex valides: i ←1 j ←i k ←i+j
x ←10.3 OK ←FAUX ch1 ←"SMI"
ch2 ←ch1 x ←4 x ←j
(voir la déclaration des variables dans le transparent précédent)
 non valides: i ←10.3 OK ←"SMI" j ←x
26
Quelques remarques
 Beaucoup de langages de programmation (C/C++, Java, …) utilisent
le signe égal = pour l’affectation ←. Attention aux confusions:
• l'affectation n'est pas commutative : A=B est différente de B=A

• l'affectation est différente d'une équation mathématique :
• A=A+1 a un sens en langages de programmation

• A+1=2 n'est pas possible en langages de programmation et n'est
pas équivalente à A=1
 Certains langages donnent des valeurs par défaut aux variables

déclarées. Pour éviter tout problème il est préférable d'initialiser les
variables déclarées
27
Exercices simples sur l'affectation (1)
Donnez les valeurs des variables A, B et C après exécution
des instructions suivantes ?
Variables A, B, C: Entier
Début
A←3
B←7
A←B
B ← A+5
C←A+B
C←B–A
Fin
28
Donnez les valeurs des variables A et B après exécution des
instructions suivantes ?
Variables A, B : Entier
Début
A←1
B←2
A←B
B←A
Fin
Les deux dernières instructions permettent-elles d’échanger les

valeurs de A et B ?
29
Ecrire un algorithme permettant d’échanger les

valeurs de deux variables A et B
30
Expressions et opérateurs
 Une expression peut être une valeur, une variable ou une
opération constituée de variables reliées par des opérateurs
exemples: 1, b, a*2, a+ 3*b-c, …
 L'évaluation de l'expression fournit une valeur unique qui est le

résultat de l'opération
 Les opérateurs dépendent du type de l'opération, ils peuvent être :

• des opérateurs arithmétiques: +, -, *, /, % (modulo), ^ (puissance)
• des opérateurs logiques: NON, OU, ET
• des opérateurs relationnels: =,  , <, >, <=, >=
• des opérateurs sur les chaînes: & (concaténation)
 Une expression est évaluée de gauche à droite mais en tenant

compte de priorités
31
Priorité des opérateurs
 Pour les opérateurs arithmétiques donnés ci-dessus, l'ordre de
priorité est le suivant (du plus prioritaire au moins prioritaire) :
• ^ : (élévation à la puissance)
• * , / (multiplication, division)
• % (modulo)
• + , - (addition, soustraction)
exemple: 2+3*7 vaut 23
 En cas de besoin (ou de doute), on utilise les parenthèses pour

indiquer les opérations à effectuer en priorité
exemple: (2 + 3) * 7 vaut 35
32
Les instructions d'entrées-sorties:
lecture et écriture (1)
 Les instructions de lecture et d'écriture permettent à la machine de
communiquer avec l'utilisateur
 La lecture permet d'entrer des donnés à partir du clavier
• En pseudo-code, on note: lire (var)

la machine met la valeur entrée au clavier
dans la zone mémoire nommée var
• Remarque: Le programme s'arrête lorsqu'il rencontre une

instruction Lire et ne se poursuit qu'après la frappe d’une valeur
au clavier et de la touche Entrée
33
Les instructions d'entrées-sorties:
lecture et écriture (2)
 L'écriture permet d'afficher des résultats à l'écran (ou de les écrire

dans un fichier)
• En pseudo-code, on note: écrire (var)

la machine affiche le contenu de la
zone mémoire var
• Conseil: Avant de lire une variable, il est fortement conseillé

d’écrire des messages à l’écran, afin de prévenir l’utilisateur de
ce qu’il doit frapper
34
Exemple (lecture et écriture)
Ecrire un algorithme qui demande un nombre entier à l'utilisateur, puis
qui calcule et affiche le double de ce nombre
Algorithme Calcul_double
variables A, B : entier
Début
écrire("entrer le nombre ")
lire(A)
B ← 2*A
écrire("le double de ", A, "est :", B)
Fin
35
Exercice (lecture et écriture)
Ecrire un algorithme qui vous demande de saisir votre nom puis
votre prénom et qui affiche ensuite votre nom complet
Algorithme AffichageNomComplet
variables Nom, Prenom, Nom_Complet : chaîne de caractères
Début
écrire("entrez votre nom")
lire(Nom)
écrire("entrez votre prénom")
lire(Prenom)
Nom_Complet ← Nom & Prenom
écrire("Votre nom complet est : ", Nom_Complet)
Fin
36
Tests: instructions conditionnelles (1)
 Les instructions conditionnelles servent à n'exécuter une instruction
ou une séquence d'instructions que si une condition est vérifiée
 On utilisera la forme suivante: Si condition alors

instruction ou suite d'instructions1
Sinon
Finsi
• la condition ne peut être que vraie ou fausse
• si la condition est vraie, se sont les instructions1 qui seront exécutées
• si la condition est fausse, se sont les instructions2 qui seront exécutées

• la condition peut être une condition simple ou une condition composée de
plusieurs conditions
37
Tests: instructions conditionnelles (2)
 La partie Sinon n'est pas obligatoire, quand elle n'existe pas et que
la condition est fausse, aucun traitement n'est réalisé
• On utilisera dans ce cas la forme simplifiée suivante:
Si condition alors
Finsi
38
Exemple (Si…Alors…Sinon)
Algorithme AffichageValeurAbsolue (version1)
Variable x : réel
Début
Ecrire (" Entrez un réel : “)
Lire (x)
Si (x < 0) alors
Ecrire ("la valeur absolue de ", x, "est:",-x)
Sinon
Ecrire ("la valeur absolue de ", x, "est:",x)
Finsi
Fin
39
Exemple (Si…Alors)
Algorithme AffichageValeurAbsolue (version2)
Variable x,y : réel
Début
Ecrire (" Entrez un réel : “)
Lire (x)
y← x
Si (x < 0) alors
y ← -x
Finsi
Ecrire ("la valeur absolue de ", x, "est:",y)
Fin
40
Exercice (tests)
Ecrire un algorithme qui demande un nombre entier à l'utilisateur,
puis qui teste et affiche s'il est divisible par 3
Algorithme Divsible_par3
Variable n : entier
Début
Ecrire " Entrez un entier : "
Lire (n)
Si (n%3=0) alors
Ecrire (n," est divisible par 3")
Sinon
Ecrire (n," n'est pas divisible par 3")
Finsi
Fin
41
Conditions composées
 Une condition composée est une condition formée de plusieurs
conditions simples reliées par des opérateurs logiques:
ET, OU, OU exclusif (XOR) et NON
 Exemples :
• x compris entre 2 et 6 : (x > 2) ET (x < 6)
• n divisible par 3 ou par 2 : (n%3=0) OU (n%2=0)
• deux valeurs et deux seulement sont identiques parmi a, b et c :

(a=b) XOR (a=c) XOR (b=c)
 L'évaluation d'une condition composée se fait selon des règles

présentées généralement dans ce qu'on appelle tables de vérité
42
Tables de vérité
C1 C2 C1 ET C2 C1 C2 C1 OU C2
VRAI VRAI VRAI VRAI VRAI VRAI
VRAI FAUX FAUX VRAI FAUX VRAI
FAUX VRAI FAUX FAUX VRAI VRAI
FAUX FAUX FAUX FAUX FAUX FAUX
C1 C2 C1 XOR C2 C1 NON C1
VRAI VRAI FAUX VRAI FAUX
VRAI FAUX VRAI FAUX VRAI
FAUX VRAI VRAI
FAUX FAUX FAUX
43
Tests imbriqués
 Les tests peuvent avoir un degré quelconque d'imbrications
Si condition1 alors
Si condition2 alors
instructionsA
Sinon
instructionsB
Finsi
Sinon
Si condition3 alors
instructionsC
Finsi
Finsi
44
Tests imbriqués: exemple (version 1)
Variable n : entier
Début
Ecrire ("entrez un nombre : ")
Lire (n)
Si (n < 0) alors
Ecrire ("Ce nombre est négatif")
Sinon
Si (n = 0) alors
Ecrire ("Ce nombre est nul")
Sinon
Ecrire ("Ce nombre est positif")
Finsi
Finsi
Fin
45
Tests imbriqués: exemple (version 2)
Variable n : entier
Début
Ecrire ("entrez un nombre : ")
Lire (n)
Si (n < 0) alors Ecrire ("Ce nombre est négatif")
Finsi
Si (n = 0) alors Ecrire ("Ce nombre est nul")
Finsi
Si (n > 0) alors Ecrire ("Ce nombre est positif")
Finsi
Fin
Remarque : dans la version 2 on fait trois tests systématiquement alors que
dans la version 1, si le nombre est négatif on ne fait qu'un seul test
Conseil : utiliser les tests imbriqués pour limiter le nombre de tests et placer
d'abord les conditions les plus probables
46
Tests imbriqués: exercice
Le prix de photocopies dans une reprographie varie selon le
nombre demandé: 0,5 DH la copie pour un nombre de copies
inférieur à 10, 0,4DH pour un nombre compris entre 10 et 20 et
0,3DH au-delà.
Ecrivez un algorithme qui demande à l’utilisateur le nombre de

photocopies effectuées, qui calcule et affiche le prix à payer
47
Tests imbriqués: corrigé de l'exercice
Variables copies : entier
prix : réel
Début
Ecrire ("Nombre de photocopies : ")
Lire (copies)
Si (copies < 10) Alors
prix ← copies*0.5
Sinon Si (copies) < 20
prix ← copies*0.4
Sinon
prix ← copies*0.3
Finsi
Finsi
Ecrire (“Le prix à payer est : ”, prix)
Fin
48
Instructions itératives: les boucles
 Les boucles servent à répéter l'exécution d'un groupe d'instructions
un certain nombre de fois
 On distingue trois sortes de boucles en langages de programmation :

• Les boucles tant que : on y répète des instructions tant qu'une certaine
condition est réalisée
• Les boucles jusqu'à : on y répète des instructions jusqu'à ce qu'une

certaine condition soit réalisée
• Les boucles pour ou avec compteur : on y répète des instructions en

faisant évoluer un compteur (variable particulière) entre une valeur initiale
et une valeur finale
(Dans ce cours, on va s'intéresser essentiellement aux boucles Tant que et

boucles Pour qui sont plus utilisées et qui sont définies en Maple)
49
Les boucles Tant que
TantQue (condition)
instructions condition Vrai instructions
FinTantQue Faux
 la condition (dite condition de contrôle de la boucle) est évaluée avant chaque

itération
 si la condition est vraie, on exécute instructions (corps de la boucle), puis, on

retourne tester la condition. Si elle est encore vraie, on répète l'exécution, …
 si la condition est fausse, on sort de la boucle et on exécute l'instruction qui

est après FinTantQue
50
Les boucles Tant que : remarques
 Le nombre d'itérations dans une boucle TantQue n'est pas connu
au moment d'entrée dans la boucle. Il dépend de l'évolution de la
valeur de condition
 Une des instructions du corps de la boucle doit absolument changer

la valeur de condition de vrai à faux (après un certain nombre
d'itérations), sinon le programme tourne indéfiniment
 Attention aux boucles infinies

 Exemple de boucle infinie :
i←2
TantQue (i > 0)
i ← i+1 (attention aux erreurs de frappe : + au lieu de -)
FinTantQue
51
Boucle Tant que : exemple1
Contrôle de saisie d'une lettre majuscule jusqu’à ce que le caractère
entré soit valable
Variable C : caractère
Debut
Ecrire (" Entrez une lettre majuscule ")
Lire (C)
TantQue (C < 'A' ou C > 'Z')
Ecrire ("Saisie erronée. Recommencez")
Lire (C)
FinTantQue
Ecrire ("Saisie valable")
Fin
52
Boucle Tant que : exemple2
Un algorithme qui détermine le premier nombre entier N tel que la
somme de 1 à N dépasse strictement 100
version 1
Variables som, i : entier
Debut
i←0
som← 0
TantQue (som <=100)
i ← i+1
som ← som+i
FinTantQue
Ecrire (" La valeur cherchée est N= ", i)
Fin
53
Boucle Tant que : exemple2 (version2)
Un algorithme qui détermine le premier nombre entier N tel que la
somme de 1 à N dépasse strictement 100
version 2: attention à l'ordre des instructions et aux valeurs initiales

Debut
som ← 0
i←1
TantQue (som <=100)
som ← som + i
i ← i+1
FinTantQue
Ecrire (" La valeur cherchée est N= ", i-1)
Fin
54
Les boucles Pour
Pour compteur allant de initiale à finale par pas valeur du pas
instructions
FinPour
i ←initiale
Vrai
i n'a pas atteint finale instructions i ← i + pas
Faux
55
Les boucles Pour
 Remarque : le nombre d'itérations dans une boucle Pour est connu
avant le début de la boucle
 Compteur est une variable de type entier (ou caractère). Elle doit
être déclarée
 Pas est un entier qui peut être positif ou négatif. Pas peut ne pas
être mentionné, car par défaut sa valeur est égal à 1. Dans ce cas, le
nombre d'itérations est égal à finale - initiale+ 1
 Initiale et finale peuvent être des valeurs, des variables définies

avant le début de la boucle ou des expressions de même type que
compteur
56
Déroulement des boucles Pour
1) La valeur initiale est affectée à la variable compteur
2) On compare la valeur du compteur et la valeur de finale :

a) Si la valeur du compteur est > à la valeur finale dans le cas d'un pas
positif (ou si compteur est < à finale pour un pas négatif), on sort de la
boucle et on continue avec l'instruction qui suit FinPour
b) Si compteur est <= à finale dans le cas d'un pas positif (ou si compteur
est >= à finale pour un pas négatif), instructions seront exécutées
i. Ensuite, la valeur de compteur est incrémentée de la valeur du pas

si pas est positif (ou décrémenté si pas est négatif)
ii. On recommence l'étape 2 : La comparaison entre compteur et

finale est de nouveau effectuée, et ainsi de suite …
57
Boucle Pour : exemple1
Calcul de x à la puissance n où x est un réel non nul et n un
entier positif ou nul
Variables x, puiss : réel
n, i : entier
Debut
Ecrire (" Entrez la valeur de x ")
Lire (x)
Ecrire (" Entrez la valeur de n ")
Lire (n)
puiss ← 1
Pour i allant de 1 à n
puiss← puiss*x
FinPour
Ecrire (x, " à la puissance ", n, " est égal à ", puiss)
Fin
58
Boucle Pour : exemple1 (version 2)
Calcul de x à la puissance n où x est un réel non nul et n un entier

positif ou nul (version 2 avec un pas négatif)

n, i : entier
Debut
Ecrire (" Entrez respectivement les valeurs de x et n ")
Lire (x, n)
puiss ← 1
Pour i allant de n à 1 par pas -1
puiss← puiss*x
FinPour
Fin
59
Boucle Pour : remarque
 Il faut éviter de modifier la valeur du compteur (et de finale) à
l'intérieur de la boucle. En effet, une telle action :
• perturbe le nombre d'itérations prévu par la boucle Pour

• rend difficile la lecture de l'algorithme
• présente le risque d'aboutir à une boucle infinie
Exemple : Pour i allant de 1 à 5

i  i -1
écrire(" i = ", i)
Finpour
60
Lien entre Pour et TantQue
La boucle Pour est un cas particulier de Tant Que (cas où le nombre d'itérations
est connu et fixé) . Tout ce qu'on peut écrire avec Pour peut être remplacé
avec TantQue (la réciproque est fausse)
Pour compteur allant de initiale à finale par pas valeur du pas
instructions
FinPour
peut être remplacé par : compteur ← initiale
(cas d'un pas positif) TantQue compteur <= finale
instructions
compteur ← compteur+pas
FinTantQue
61
Lien entre Pour et TantQue: exemple
Calcul de x à la puissance n où x est un réel non nul et n un entier positif ou
nul (version avec TantQue)
n, i : entier
Debut
Ecrire (" Entrez la valeur de x ")
Lire (x)
Ecrire (" Entrez la valeur de n ")
Lire (n)
puiss ← 1
i←1
TantQue (i<=n)
puiss← puiss*x
i ← i+1
FinTantQue
Fin
62
Boucles imbriquées
 Les instructions d'une boucle peuvent être des instructions
itératives. Dans ce cas, on aboutit à des boucles imbriquées
 Exemple: Exécution
Pour i allant de 1 à 5 OX
Pour j allant de 1 à i OOX
écrire("O") OOOX
FinPour OOOOX
écrire("X") OOOOOX
FinPour
63
Les boucles Répéter … jusqu’à …
Répéter
instructions instructions
Jusqu'à condition
Faux
condition
Vrai
 Condition est évaluée après chaque itération
 les instructions entre Répéter et jusqu’à sont exécutées au moins une fois et
leur exécution est répétée jusqu’à ce que condition soit vrai (tant qu'elle est
fausse)
64
Boucle Répéter jusqu’à : exemple
Un algorithme qui détermine le premier nombre entier N tel que la somme de 1
à N dépasse strictement 100 (version avec répéter jusqu'à)

Debut
som ← 0
i←0
Répéter
i ← i+1
som ← som+i
Jusqu'à ( som > 100)
Ecrire (" La valeur cherchée est N= ", i)
Fin
65
Choix d'un type de boucle
 Si on peut déterminer le nombre d'itérations avant l'exécution de la
boucle, il est plus naturel d'utiliser la boucle Pour
 S'il n'est pas possible de connaître le nombre d'itérations avant

l'exécution de la boucle, on fera appel à l'une des boucles TantQue
ou répéter jusqu'à
 Pour le choix entre TantQue et jusqu'à :
• Si on doit tester la condition de contrôle avant de commencer les

instructions de la boucle, on utilisera TantQue
• Si la valeur de la condition de contrôle dépend d'une première

exécution des instructions de la boucle, on utilisera répéter jusqu'à
66
Langage C
67
Ecrire un programme
 Un programme se constitue :
• D’une fonction principale
• De plusieurs fonctions secondaires
 Une fonction est une suite d’instructions qui manipulent

des variables contenant différents types de données.
 Les instructions sont exécutés séquentiellement (les

unes après les autres) mais certaines sont répétables.
 Par programme, on peut aussi parler de code source (ou

code ou source plus simplement).
68
Les commentaires (1)
 Un commentaire est une portion du programme qui n’est pas

exécutée.
 On l’utilise pour :
• Insérer des informations générales :
• nom du programmeur
• date de la dernière modification
• présentation de la tâche accomplie par le programme
• …
• Insérer des explications sur une instruction ou un bloc
d’instructions :
• Quelle est sa fonction ?
• Pourquoi en a-t-on besoin ?
• …
• Neutraliser une instruction ou un bloc d’instructions (phases de
déboguage ou de test)
69
Les commentaires (2)
 Syntaxe sur plusieurs lignes : /* */

/* 1 - voici un
commentaire sur
plusieurs lignes */
 Syntaxe en fin de ligne : //

// 2 - commentaire isolée sur une ligne
return 0; // 3 - commentaire en fin de ligne
 Très utile pour les autres programmeurs

relisant votre code ou pour vous-même.
70
L’indentation
 L’indentation est un décalage vers la droite du
code (via une tabulation).
 On l’utilise pour rendre le code plus clair et plus
lisible.
 On l’utilise :
• dans les fonctions,
• dans les tests,
• dans les boucles.
 Après une accolade ouvrante { :
indentation / décalage vers la droite
 Accolade fermante } :
fin de l’indentation / décalage vers la gauche
71
Les variables
 Une variable sert à stocker une information
(donnée sous la forme d’une valeur).
 Une variable est définie par :

• Son nom qui permet l’accès à la donnée stockée
• Son type qui décide du type de donnée à stocker
 Syntaxe de la déclaration d’une variable :
type nom_de_la_variable ;
72
Les variables
 En résumé, il existe 3 types de données de base :
Les nombres entiers Les nombres réels

int float
ex : -2, -1, 0, 1, 2 ex : 3.1415
Les caractères
char
ex : ‘A’, ‘b’, ‘0’, ‘é’, ‘!’
73
Les variables
 Choix du nom :
• Un nom de variable commence par une lettre.
• Un nom de variable peut se composer :
• de chiffres (09)
• de lettres minuscules (az)
• de lettres majuscules (AZ)
• du symbole ‘_’
• Les lettres accentuées, les espaces et les symboles divers
sont interdits.
• On privilégie les noms significatifs : pi au lieu de p
• Exemples : pi, nombre_d_habitants, TauxTVA, A, R2D2, b
• Rq : ce sont les mêmes règles pour les noms des fonctions.
74
Les variables
 Déclaration de plusieurs variables de même type :

type nom_de_la_variable_1, nom_de_la_variable_2 ;
 Déclaration et affectation d’une valeur :

type nom_de_la_variable = valeur ;
 Exemples :
int g ; // déclaration simple
float PrixHT, TauxTVA, PrixTTC ; // déclaration multiple
float pi = 3.141593 ; // déclaration et initialisation
75
Les valeurs
 Un nombre réel s’écrit avec un point et non avec une
virgule (écriture anglo-saxonne).
 On écrit les caractères entre apostrophes : ' '
 Il existe des caractères spéciaux :

• \n : fin de ligne (newline)
• \t : tabulation horizontale
• \\ : blackslah
• \? : point d’interrogation
• \' : apostrophe
• \" : guillemet
76
Mathématique vs C (1)
 En mathématique : La variable est une inconnue recouvrant
plusieurs valeurs.
y=3x+2
 les variables x et y répondant à cette équation sont une
infinité
ax2 + bx + c = 0
 la variable x répondant à cette équation a 0, 1 ou 2 valeurs
 En C : La variable est connue et a une et une seule valeur à

un moment donné.
77
L’affectation
 L’affectation consiste à donner une valeur (à droite) à une variable (à gauche).
 L’opérateur d’affectation s’écrit : =
 Syntaxes :
nom_de_variable = valeur ;
 Plusieurs possibilités existent :

• Affectation d’une valeur : pi = 3.1415 ; c = 'A' ;
• Affectation de la valeur d’une autre variable : a = b ;
• Affectation de la valeur d’une expression : a = b + 2 ; a = a + 1 ;
• Affectation de la valeur retournée par une fonction : c = carre(2) ;
78
L’affectation
 La valeur affectée doit être du même type que la
variable.
 Risque : une perte de données.
 Exemples :
int i ;
i = 423.97 ; // Valeur affectée en pratique : 423
float j ;
j = 32 ; // Valeur affectée en pratique : 32.0
79
Mathématique vs C (2)
 En mathématique : Le symbole = indique l’égalité entre 2 termes.
 En C : Le symbole = sert à affecter une valeur à une variable.
 Exemple 1 :
Soit A = B et B = A :
• En mathématique, les deux propositions sont équivalentes.
• En C, ce n’est pas le cas car ça revient à affecter la valeur de B à A et
à affecter la valeur de A à B : ce sont deux choses bien différentes.
 Exemple 2 :
Soit A = A + 1 :
• En mathématique, c’est une équation sans solution.
• En C, c’est une opération courante consistant à incrémenter la
variable.
 Rq : En C, l’égalité entre 2 termes nécessite d’utiliser l’opérateur de

comparaison d’égalité == .
80
Lecture séquentielle
En C, l’ensemble des instructions forme une séquence lue / exécutée de
manière séquentielle, c’est-à-dire qu’une instruction est traitée après
l’autre.
 L’ordre d’écriture des instructions est donc primordiale !
Exemple 1 : Exemple 2 :
int A ; int A ;
A = 34 ; A = 12 ;
A = 12 ; A = 34 ;
Valeur de A à la fin de
12 34
cette séquence :
81
Opérateurs
 Un opérateur est un signe (symbole) qui relie deux valeurs pour produire
un résultat :
• opération mathématique,
• opération logique,
• comparaison
• …
 Syntaxe usuelle* :
[terme_1] [opérateur] [terme_2]
 Les types des valeurs liées par un opérateur doivent être identiques.
* : il existe des exceptions
82
Opérations mathématiques
 Opérateurs numériques ou mathématiques :
• Addition : +
• Soustraction : –
• Multiplication : *
• Division : /
• Reste de la division entière : % (modulo)
 Priorités classiques : 3 + 5 * 10 donne 53
 Rôle des parenthèses classique :

3 + ( 5 * 10 ) donne 53 mais ( 3 + 5 ) * 10 donne 80
83
 Règle : Si toutes les valeurs et/ou variables d’une
opération sont de type entier alors le résultat est
de type entier et doit être affecté (stocké) dans
une variable de type entier.
Dans le cas de la division « entière » :
int x ;
x = 17 / 5 ; // x vaut 3
x = 4 / 5 ; // x vaut 0
 Règle : même chose avec le type réel.
Dans le cas de la division « réelle » :
float x ;
x = 17.0 / 5.0 ; // x vaut 3.4
x = 4.0 / 5.0 ; // x vaut 0.8
84
 Pourquoi ne pas utiliser uniquement le
type float ?
Pour économiser la mémoire : une

variable de type float est plus
gourmande qu’une variable de type int.
85
La conversion de type (cast)
 C’est une conversion de type ponctuel.
 Syntaxe : (type) valeur
 Exemple d’utilisation :
• Soit les variables :
int nb_gateau ; // nombre de gâteaux
int nb_enfant ; // nombre d’enfants
float parts ; // portions à manger
• On veut calculer le nombre de parts en divisant le nombre
de gâteaux par le nombre d’enfants.
• Solution : parts = (float) nb_gateau / (float) nb_enfant ;
86
• Modulo % : Puisque le résultat d’une division entre deux entiers
est un entier, il existe une cinquième opération mathématique qui
permet de calculer le reste d’une telle division  le modulo est
une opération entre deux entiers uniquement.
int quotient, reste ;
quotient = 17 / 5 ;
reste = 17 % 5 ;
Numérateur Dénominateur
ou dividende ou diviseur
17 5 Variable Valeur
2 3 quotient 3
Reste Quotient reste 2
87
Opérateurs ++ et --
 Incrémentation (++) et décrémentation (--)
• Forme préfixée (++i , --i) : la variable i est
incrémentée/décrémentée avant que sa valeur ne soit
estimée.
Ex : n = 5; x = ++n; // x vaut 6
• Forme postfixée (i++ , i--) : la variable i est

incrémentée/décrémenté après que sa valeur ne soit estimée.
Ex : n = 5; x = n++; // x vaut 5
• Formes équivalentes :
i++;  i=i+1;  i+=1;
i--;  i=i-1;  i-=1;
88
Lecture / Ecriture
Consignes Lecture des
consignes
Utilisateur Programme
Ecriture des
Résultats résultats
89
Lecture / Ecriture
 Lecture des données fournies par l’utilisateur : scanf ( )
• Données saisies au clavier
• Nécessite de déclarer le fichier d’en-tête : stdio.h
• Exemple : saisie d’un entier
scanf ( " %d " , &nb_gateau ) ;

séparateur fin de l’instruction
lettre qui dépend du type

symbole % de donnée à saisir :
obligatoire - d pour les entiers nom de la
- f pour les réels variable qui va
- c pour les caractères symbole & stocker la
obligatoire donnée saisie
" %d "
& nb_gateau
délimiteurs obligatoires
90
Lecture / Ecriture
• Saisie d’un réel : scanf( " %f " , &tauxTVA ) ;
• Saisie d’un caractère : scanf( " %c " , &reponseQCM )
;
• Saisie de plusieurs données de même types :
scanf ( " %d %d " , &nb_gateau , &nb_enfant ) ;
• Saisie de plusieurs données de types différents :
scanf ( " %d %f " , &nb_produit , &prixTTC ) ;
• Dès que le programme rencontre une instruction

comportant un scanf(), l’exécution s’interrompt et
attend la frappe d’une valeur au clavier.
91
Lecture / Ecriture
 Ecriture de résultats du programme ou d’autres informations :
printf ( )
• Affichage à l’écran
• Nécessite de déclarer le fichier d’en-tête : stdio.h
• Exemple : affichage d’un réel
printf ( " %f " , PrixTTC ) ;

séparateur fin de l’instruction
lettre qui dépend du type
symbole % de donnée à afficher :
obligatoire - d pour les entiers nom de la
- f pour les réels variable dont
- c pour les caractères on veut afficher
la valeur
" %f "
PrixTTC
délimiteurs obligatoires
92
Lecture / Ecriture
 On a souvent besoin d’afficher des « libellés » sous la forme de

textes qui informent l’utilisateur de ce que fait ou veut le
programme : on utilise printf pour faire cela.
Exemple : printf ( " Entrez votre age : " ) ;

scanf (" %d ", &age );
 Pour afficher plusieurs libellés ou valeurs de variables en une

seule instruction :
Ex : printf( " Votre age est : %s \n " , age );

printf( " Vous pesez %f et mesurez %f " , poids , taille );
93
La fonction principale
 La fonction principale (et les instructions qu’elle contient)

s’exécute toujours en premier.
 Syntaxe :
int main (int argc, char *argv[ ])
{
/* on écrit le programme ici */
return 0;
}
 Autre syntaxe : int main (void) { … }
94
Les tests
 Définition
• Au lieu de lire séquentiellement les instructions du

début jusqu’à la fin, le test conditionnel offre une
alternative (on pourra parler de structure alternative),
un choix entre plusieurs jeux d’instructions en fonction
de une ou plusieurs conditions.
• 2 mots-clés : if et else
95
Les tests
 Syntaxes :
if ( condition )
{ if ( condition1 )
[liste d’instructions] {
} [liste d’instructions 1]
}
else if ( condition2 )
{
if ( condition ) [liste d’instructions 2]
{ }
[liste d’instructions 1] …
} else
else {
{ [liste d’instructions n]
[liste d’instructions 2] }
}
96
Les tests
 Si la condition est vérifiée (valeur différente de 0), le programme
exécute la liste d’instructions qui suit.
 Si la condition n’est pas vérifiée (valeur de l’expression nulle) :

• Structure en if … : on sort du test
• Structure en if … else … : on exécute la seconde liste d’instructions
• Structure en if … else if … : on teste la nouvelle condition
 La condition s’exprime le plus souvent sous la forme d’une

expression utilisant :
• des opérateurs de comparaison
• des opérateurs logiques
97
Les tests
 Opérateurs de comparaison
• Egalité : ==
• Différence : !=
• Supérieur : >
• Supérieur ou égal : >=
• Inférieur : <
• Inférieur ou égal : <=
 Opérateurs logiques
• ET : &&
• OU : ||
• Négation : ! (ou opérateur unaire)
98
Les tests
 Exemple :
int main (int argc, char *argv[])

{
float note_orale, note_ecrite, moyenne ;
printf ("Entrez la note de l’oral : ") ; scanf ("%f",&note_orale) ;
printf ("Entrez la note de l’écrit : ") ; scanf ("%f",&note_ecrite) ;
moyenne = ( 2.0 * note_ecrite + note_orale ) / 3.0 ;
if ( moyenne >= 10.0 )
{
printf ("Reçu !") ;
}
else Est-ce que la valeur de la
{ variable moyenne est supérieure
printf ("Recalé !") ;
} ou égale à 10 ?
return 0 ;
}
99
Les tests
 Une comparaison se fait toujours entre deux termes.
 Si on souhaite savoir si la valeur d’une variable est comprise entre deux

valeurs min et max :
• On n’écrira pas : if ( 5 < x < 8 ) … 
• On écrira : if ( (5<x) && (x<8) ) … 
 Un tel test implique 2 conditions reliées par l’opérateur logique && (ET).
 On parle alors de condition composée.
 Plus généralement, dès que plusieurs conditions sont nécessaires pour

exécuter une liste d’instructions, on lie ces conditions par les opérateurs
logiques ET et OU.
100
Les tests
 Dans une condition composée, toutes les règles de la logique

booléenne sont valables, notamment les tables de vérité :
5<x x<8 if ((5<x)&&(x<8)) 5<x x<8 if ((5<x)||(x<8))
FAUX FAUX FAUX FAUX FAUX FAUX 5<x if ( !(5<x) )
FAUX VRAI FAUX FAUX VRAI VRAI FAUX VRAI
VRAI FAUX FAUX VRAI FAUX VRAI VRAI FAUX
VRAI VRAI VRAI VRAI VRAI VRAI
 Attention aux cas particuliers :

• Conditions toujours fausses : if ( (x<10) && (x>15) ) …
• Conditions toujours vraies : if ( 10 < 15 ) …
101
Les tests
 Soit :
int Temp;
printf("Entrez la température de l’eau :"); scanf("%d",&Temp);
if ( Temp <= 0 )
{
printf("C’est de la glace !");
}
if ( (Temp > 0) && (Temp < 100) ) • 3 tests successifs (perte
de temps possible)
{
printf("C’est du liquide !"); • 3 conditions similaires
}
dont 1 composée
if ( (Temp >= 100) )
{
printf("C’est de la vapeur !");
}
102
Les tests
 On peut réécrire le code précédent en imbriquant les tests :
int Temp ;
printf("Entrez la température de l’eau :"); scanf("%d",&Temp);
if ( Temp <= 0 )
{
}
else
{ • 2 tests imbriqués (gain
if ( Temp < 100 ) de temps possible)
{ • 2 conditions simples
printf("C’est du liquide !");
}
else
{
}
}
103
Les tests
 On peut également utiliser else if :
int Temp;
printf("Entrez la température de l’eau :");
scanf("%d",&Temp);
if ( Temp <= 0 )
{
}
else if ( Temp < 100 )
{
printf("C’est du liquide !");
}
else
{
}
104
Les boucles
105
Les boucles
 Également appelées structures répétitives, ou structures

itératives, les boucles permettent de répéter l’exécution d’une
instruction ou d’un bloc d’instructions sans avoir à les réécrire.
 3 types de boucles existent :

• « Pour » (for)
• « Tant que » (while)
• « Faire tant que » (do while)
106
Les boucles
 Syntaxe et exemple de la boucle for :
• for ( expr1 ; expr2 ; expr3 ) { … }
for ( cpt = 1 ; cpt<=500 ; cpt ++ )

{
printf("Je ne dois pas lancer d’avion en papier en classe.\n");
}
• expr1 : initialisation de la boucle

• expr2 : comparaison déterminant l’arrêt de la boucle
(condition)
• expr3 : évolution du compteur (ici un incrémentation simple)
107
Les boucles
 Syntaxe et exemple de la boucle while :
• while ( condition ) { … }
char choix ;
printf("Voulez vous un café ? (O/N)") ;
scanf("%c",&choix) ;
while ( (choix != 'O') && (choix != 'N') )
{
printf("Réponse non valide ; recommencez :");
}
• condition : condition nécessaire à la répétition (tant que la

condition est vraie, on répète les instructions)
108
Les boucles
• Il est obligatoire que les variables utilisées dans la condition de

la boucle « tant que » aient une valeur initiale. Sinon le test ne
peut pas se faire.
char choix ;
{
printf("Réponse non valide ; recommencez :");
}
109
Les boucles
• Remarque : pour éviter d’écrire 2 fois l’instruction de saisie de

la variable choix, on peut lui affecter arbitrairement une valeur
permettant à la condition d’être vraie (ici n’importe quelle lettre
autre que ‘O’ ou ‘N’ ).
char choix = 'C' ;

{
}
• Ce changement de stratégie pour l’initialisation de la variable

choix a entraîné une modification du jeu d’instructions.
110
Les boucles
 Syntaxe et exemple de la boucle do while :
• Variante de la boucle while permettant d’exécuter au moins

une fois les instructions de la boucle avant de tester la
condition.

do
{
}
while ( (choix != 'O') && (choix != 'N') ) ;
111
Les boucles
char choix='X' ;
scanf("%c",&choix) ; while ( (choix!='O') && (choix!= 'N') )
while ( (choix!='O') && (choix!= 'N') ) {
{ scanf("%c",&Rep) ;
scanf("%c",&choix) ; }
}
do
{
}
while ( (choix!='O') && (choix!= 'N') );
On peut ne pas exécuter la boucle.
On exécute au moins une fois la

boucle.
112
Les boucles
 Les deux erreurs à ne pas faire :
• Une condition toujours fausse qui empêche d’entrer

dans la boucle : la boucle ne sert donc jamais !
choix = 'O';
while ( ( choix != 'O' ) && ( choix != 'N' ) )
{…}
• Une condition toujours vraie qui empêche de sortir de la

boucle : on a une boucle infinie.
while ( ( choix != 'O' ) && ( choix != 'N' ) )

{
…
choix  'X';
}
113
Les tableaux
 Utilité des tableaux :
• Exemple 1 : une variable pour chaque information utile
float N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11,N12,m;
printf("Entrez 12 valeurs :");
scanf("%f%f%f%f%f%f%f%f%f%f%f%f ",&N1,&N2,&N3,&N4,&N5,&N6,&N7,&N8,&N9,&N10,&N11,&N12);
m = (N1+N2+N3+N4+N5+N6+N7+N8+N9+N10+N11+N12)/12.0;
• Exemple 2 : on ne conserve aucune information utile
int i; float val, m=0.0;

printf("Entrez 12 valeurs :");
for(i=0;i<12;i++)
{
scanf("%f ",&val);
m = m + val;
}
m = m / 12.0;
114
Les tableaux
 Il faut une solution qui :
• ne nécessite pas autant de variables que de valeurs à saisir ;
• permette de stocker toutes les valeurs saisies.
 Cette solution est le tableau de valeurs :
• une seule variable pouvant contenir plusieurs valeurs ;
• chaque valeur est accessible via un indice de position.
int i;
 Exemple : float val[12],m=0.0;
printf("Entrez les 12 valeurs :");
for(i=0;i<12;i++)
{
scanf("%f ",&val[i]);
m = m + val[i];
}
m = m / 12.0;
115
Les tableaux
 Définitions :
• Un ensemble de valeurs portant le même nom de
variable et repérées par un indice, s’appelle un tableau,
ou encore une variable indicée.
• La déclaration d’un tableau est similaire à celle d’une
variable avec la taille précisée entre crochets en plus (à
répéter autant de fois que de dimensions).
• En dehors de la déclaration du tableau, le nombre entier
qui sert à repérer chaque valeur s’appelle l’indice.
• Chaque fois que l’on doit désigner un élément du
tableau, on fait figurer le nom du tableau, suivi de l’indice
de l’élément entre crochets.
116
Les tableaux
 Déclaration :
type nom_du_tableau [taille1] ( [taille2] … ) ;
Ex1 : float note[12]; // tableau de 12 notes

Ex2 : int matrice[3][4]; // tableau de 3 lignes et 4 colonnes
Ex3 : int image[256][256][3]; /* image de 256 lignes, 256 colonnes et 3
niveaux de couleurs */
• Un tableau peut être de n’importe quel type : tableau d’entiers,

de réels, de caractères…
• Attention : En C, on accède au premier élément d’un tableau

par l’indice 0 et au dernier par l’indice taille-1 : note[0], note[1],
… , note[11].
117
Les tableaux
 Un tableau est facile à manipuler grâce aux boucles.
int main () somme = 0.0 ;

{ for (i=0;i<12;i++)
float note[12] ; {
float moyenne, somme ; somme = somme + note[ i ] ;
int i ; }
for (i=0;i<12;i++) moyenne = somme / 12.0 ;
{ printf("La moyenne est : %f ", moyenne) ;
printf("Entrez la note no%d", i+1) ; return 0;
scanf("%f", &note[ i ] ) ; }
}
118
Les tableaux
 Erreurs à ne pas faire :
• Utiliser un mauvais indice. Avec float note[12], les

seuls indices valables sont : 0, 1, 2, 3, 4, 5, 6, 7, 8,
9, 10 et 11 (tous positifs ou nul, entiers, et
inférieurs à la taille du tableau).
• Confondre l’indice d’un élément d’un tableau et la

valeur de cet élément : note[3] ne vaut pas
forcément 3.
119
Les fonctions prédéfinies
 En C, divers traitements courants dont le développeur peut

avoir besoin sont prédéfinies. Les avoir à disposition évite de
devoir les reprogrammer systématiquement.
 Ces traitements font l’objet de fonctions déclarées dans des

fichiers d’en-tête. Tout programme faisant appel à ces
fonctions doit débuter par la déclaration des fichiers d’en-tête.
Exemple :
#include<stdio.h>  printf(), scanf()
 Plus de détails dans des livres ou sur des sites internet.

Exemple : http://www.cplusplus.com/reference/clibrary/
120
Les fonctions prédéfinies
 Quelques fonctions de math.h

• Attention aux types des arguments d’entrée et des valeurs
retournées.
• cos(), sin(), tan(), acos(), asin(), atan() : fonctions
trigonométriques (en radians)
• exp(), log(), log10() : fonctions exponentielles et
logarithmiques
• floor(), ceil() : arrondi à l’entier inférieur, supérieur
• fabs() : valeur absolue
• pow(x,y) : renvoie x à la puissance y
• sqrt() : racine carrée
•…
121
Les fonctions
 Certains traitements propres à l’application développée

peuvent également faire l’objet d’une écriture sous forme de
fonction. C’est le cas pour :
• Des traitements régulièrement utilisés
• Des traitements que l’on souhaite distinguer de la fonction
principale ( confort d’écriture et lisibilité du programme)
 Terminologie : dans la littérature, on parle de fonction quand il

y a renvoi de donnée et de procédure autrement.
122
Les fonctions
parenthèses obligatoires
 Syntaxe : même si pas d’arguments
type nom_de_la_fonction ( [liste des arguments] )

{
… facultatif : type et nom des arguments
} d’entrée, séparés par des virgules
doit respecter les mêmes règles d’écriture que

les noms de variable
type de la valeur retournée par la fonction ou

void (pas de valeur retournée)
123
Les fonctions
 Exemples :
• Fonction calculant la distance euclidienne entre 2 points :
float euclide ( float x1, float y1, float x2, float y2 )

{
return sqrt( (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) );
}
• Fonction retournant une réponse universelle :

int f ( )
{
return 42;
}
124
Les fonctions
 Si la fonction renvoie une valeur, sa dernière
instruction est de la forme :
return expression ;
 La liste des arguments d’entrée sert également de

déclaration de variable :
int fct ( int p )
{ double déclaration
int p;  erreur !
…
125
Les fonctions
 Exemples d’appel de fonction :
• res = euclide(a,b,c,d);
• printf("%d" , f() );
• res2 = f() + 3 + euclide(0,0,1,1);
 Le passage d’arguments est automatique :

…
res = euclide(a,b,c,d); // dans main()
… La valeur de a est
passée dans x1, …
float euclide (float x1, float y1, float x2, float y2)
{…}
126
Fonctions récursives
 Programmation récursive : le programme qui se
rappelait lui-même !
long fact (int N)

{
if ( N == 0 )
{ return 1; }
else
{ return fact(N-1) * N; }
}
127
Structure d’un programme en C
[déclaration des fichiers d’en-tête]

[déclaration des constantes symboliques]
[déclaration des prototypes des fonctions secondaires]
{
[déclaration des variables]
[séquence d’instructions]
return 0;
}
[écriture des fonctions secondaires]
128
Ecrire un programme en C
 Exemple : déclaration du fichier d’en-tête permettant

d’utiliser printf() et scanf()
#include<stdio.h>

début de la fonction « principale »
{
int n; déclaration d’une variable n en entier message à l’utilisateur
(s’affiche à l’écran)
printf("Entrez une valeur non nulle : ");
saisie de la valeur entrée au clavier et stockage dans n
scanf("%d",&n);
printf("L’inverse de %d est %f.",n,1/(float)n);
return 0; fin de la fonction
« principale » message affichant les valeurs de n et
} de 1/n
129

Algo Et C

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

Algo Et C

Transféré par

Droits d'auteur :

Formats disponibles

Cours d’Informatique

Département de Génie Electrique,

• Etre capable de mettre en oeuvre ces concepts pour analyser des

• Algorithmique (affectation, instructions conditionnelles, instructions

 Eléments d’un système informatique

 La mémoire : stocke les données et les programmes.

 Les périphériques d’entrée : permettent d’acquérir des

 Les périphériques de sortie : permettent de restituer des

 Les bus : sont le média de communication.

 Unité centrale (le boîtier)

 Les Systèmes d’Exploitation (ou Operating

• Programme central de l’ordinateur

• Responsable de la liaison entre les ressources

• Gestion des périphériques (affichage à l'écran, lecture du

• Gestion des utilisateurs et de leurs données (comptes,

• Interface avec l’utilisateur (textuelle ou graphique):

• Contrôle des programmes (découpage en taches, partage

• A chaque instruction correspond une action du processeur

 Intérêt : écrire des programmes (suite consécutive

• Exemple: un programme de gestion de comptes bancaires

 Contrainte: être compréhensible par la machine

 Un bit (binary digit) = 0 ou 1 (2 états électriques)

 Une combinaison de 8 bits= 1 Octet  28 256 possibilités qui permettent

 Les opérations logiques et arithmétiques de base (addition,

 Idée: trouver un langage compréhensible par l'homme qui sera

 Apparition des langages évolués

Code source Compilateur ou

 Interpréteur: traduire au fur et à mesure les instructions du

 Deux types de langages:

 Choix d’un langage?

La réalisation de programmes passe par l’écriture d’algorithmes

 Un algorithme est une description complète et détaillée des actions à

• Intérêt: séparation analyse/codage (pas de préoccupation de syntaxe)

 L’algorithmique désigne aussi la discipline qui étudie les algorithmes

 Une bonne connaissance de l’algorithmique permet d’écrire des

• Le pseudo-code: représentation textuelle avec une série de

Notions et instructions de base

 Une variable désigne en fait un emplacement mémoire dont

 Règle : Les variables doivent être déclarées avant d’être

 doit être constitué uniquement de lettres, de chiffres et du

 doit être différent des mots réservés du langage (par exemple en

 La longueur du nom doit être inférieure à la taille maximale spécifiée

Remarque: en pseudo-code algorithmique, on va respecter

 Type caractère: lettres majuscules, minuscules, chiffres, symboles, …

 Remarque: pour le type numérique on va se limiter aux entiers

 En pseudo-code, l'affectation se note avec le signe ←

• l'affectation n'est pas commutative : A=B est différente de B=A

• A=A+1 a un sens en langages de programmation

 Certains langages donnent des valeurs par défaut aux variables

Les deux dernières instructions permettent-elles d’échanger les

Ecrire un algorithme permettant d’échanger les

 L'évaluation de l'expression fournit une valeur unique qui est le

 Les opérateurs dépendent du type de l'opération, ils peuvent être :

 Une expression est évaluée de gauche à droite mais en tenant

 En cas de besoin (ou de doute), on utilise les parenthèses pour

 La lecture permet d'entrer des donnés à partir du clavier

• En pseudo-code, on note: lire (var)

• Remarque: Le programme s'arrête lorsqu'il rencontre une

 L'écriture permet d'afficher des résultats à l'écran (ou de les écrire

• En pseudo-code, on note: écrire (var)

• Conseil: Avant de lire une variable, il est fortement conseillé

 On utilisera la forme suivante: Si condition alors

• si la condition est fausse, se sont les instructions2 qui seront exécutées