‫بـسـم الله الرحــمــن‬

‫الرحـــيــم‬

‫)‪GI(S1‬‬
‫‪Algorithmique debase‬‬
‫‪2010/2011‬‬
 Ait Moussa

Département de mathématiques et
d'Informatique
Bureau m2
 Plan duI:cours
Partie
Introduction à l'informatique
Initiation à Windows

Partie II:
Algorithmique et Langage de
programmation C
Partie I
algorithmique et C
Chapitre 1
Les éléments de base, les opérateurs
et les expressions
Chapitre 2
Entrées/sorties
Chapitre 3
Structures de contrôle
Chapitre 4
Les boucles
Chapitre 5
Les tableaux
Chapitre 6
Les fonctions
Références
Langage C.
Code :
PC Poche : Langage C.
Code :
Langage C.
Code :
Programmer en langage C: cours et
exercices.
Claude DeLannoy
 Chapitre 1

Les éléments de base, les opérateurs et

les expressions
Introduction
On appelle langage informatique un langage destiné
à décrire l'ensemble des actions consécutives
qu'un ordinateur doit exécuter.
Le langage utilisé par le processeur, est appelé
langage machine. Il s'agit d'une suite de 0 et de 1
(du binaire).
Toutefois, le langage machine n'est pas
compréhensible facilement par l'humain. Ainsi, il
est plus pratique de trouver un langage
intermédiaire, compréhensible par l'homme, qui
sera ensuite transformé en langage machine pour
être exploitable par le processeur.
Introduction (suite)
Un langage informatique a donc plusieurs
avantages:
il est plus facilement compréhensible que le
langage machine
il permet une plus grande portabilité, c'est-à-
dire une plus grande facilité d'adaptation sur
des machines de types différents
Introduction (suite)
Voici une liste de quelques langages
informatiques existants :
Basic, Pascal, Fortran, C, C++, Java …
Structure d’un programme C
Le programme qui écrit « premier programme en c »
est le suivant :
#include<stdio.h>
main()
{
printf("premier programme en c");
} programme
Ce programme montre qu’un langage de
programmation particulier est défini par :
Son lexique : c’est-à-dire la forme que devront
avoir les mots constituant un programme
Sa syntaxe : c'est-à-dire la forme que devront
avoir les programmes pour pouvoir être
traduits automatiquement par le compilateur.
Sa sémantique : c'est-à-dire son sens, ou ce que
tel programme fera faire à l'ordinateur,
quand il sera exécuté.
La difficulté majeure pour le programmeur
peut alors être le respect de cette forme, qui
change d'un langage à un autre.

Il est important d’écrire des algorithmes.

Quant aux carrés et aux racines qui égalent le nombre, c’est comme
lorsque tu dis : un carré et dix de ses racines égalent trente-neuf
dirhams.
Sa signification est que tout carré, si tu lui ajoutes l ’équivalent de dix
de ses racines [est tel que] cela atteindra trente-neuf.
Son procédé [de résolution] consiste à diviser les racines par deux, et
c ’est cinq dans ce problème. Tu le multiplies par lui-même et ce sera
vingt-cinq.
Tu l’ajoutes à trente-neuf. Cela donnera soixante-quatre. Tu prends
alors sa racine carrée qui est huit et tu en retranches la moitié [du
nombre] des racines et c’est cinq. Il reste trois et c’est la racine du
carré que tu cherches et le carré est neuf.

AL-Khawarizmi, L’abrégé du calcul par le Jabr et la Muqabala,

d’après l’édition arabe de A.M. Mashrafa et M.M. Ahmad, Le Caire,1968, p.18-19.
Le nom d ’al-Khawarizmi est à l ’origine du mot algorithme.
Le texte décrit un algorithme de résolution de l ’équation x2+10 x=39
Définition: Un algorithme est une
suite finie d’étapes (instructions) à
exécuter dans un ordre bien
déterminé pour résoudre un
problème donné.

 C’est la description d'un processus

de résolution d'un problème
donné.
Exemples d’algorithmes
résoudre une équation du
second degré
démarrage d'un véhicule
trouver un chemin dans un
labyrinthe
division de nombres entiers
…
Caractéristiques: Un algorithme doit
être:

 Clair
 Exprimé dans un langage
compréhensible par le lecteur (l’être
humain)

 La notation algorithmique doit être

indépendante des particularités des
langages de programmation et du
système informatique.
De l’algorithme au Programme
Avant que l’algorithme soit exécuté
par l’ordinateur et fournir des
résultats, il doit être traduit dans
un langage de programmation.

 On part de l'algorithme, puis on

code (traduit) les instructions
dans un langage de
programmation.
Définition: Un programme est un
algorithme écrit au moyen d’un
langage de programmation
Du programme à l’exécutable

Pour que le programme soit

exécuté par un ordinateur, il doit
être traduit en langage machine.

Cette traduction s’effectue à l’aide

d’un programme appelé
compilateur.
Phase de conception

Algorithme utilisateur

Phase de programmation

Programme
compilateur

Phase de compilation
Programme machine
(code binaire)
ordinateur

Phase d’exécution
Résultat
Etapes à suivre pour décrire un algorithme:

Définir les données d’entrée et les résultats

souhaités du problème

Définir les tâches à réaliser de manière

progressive : on part d’un algorithme très
général, ensuite par des affinements
successives on arrive à un algorithme dont
chaque étape est suffisamment détaillée et
précise pour que son exécution par le
processeur soit possible.
Exemple:
Considérons le problème de
recherche des racines réelles de
l’équation du second degré :
a*x2 + b*x + c = 0 avec a≠0
Données d’entrée a b c

Algorithme

Résultat souhaité x
Algorithme 1: un algorithme
général
Calculer le discriminant.
Déduire les solutions.

 l’algorithme 1 défini les tâches à

réaliser, mais il n’est pas
suffisamment détaillé pour
décrire de manière précise les
solutions.
Algorithme 2: l’étape, déduire les
solutions de l’algorithme 1, n’est
pas suffisamment explicite, nous
donnons plus de précisions sur
cette étape (on affine l’algorithme
1):
 Calculer le discriminant;
 Déduire les solutions:
 si le discriminant est positif, l’équation
a 2 racines réelles ;
 si le discriminant est nul, l’équation a
une racine double ;
 si le discriminant est strictement
négatif, l’équation n’a pas de racine
réelle.
L’algorithme 2 est plus précis
que l’algorithme 1, mais il
n’est pas suffisamment détaillé
pour décrire de manière
précise les solutions.
Algorithme 3: on détaille l’algorithme
2 en décrivant les solutions et en
précisant le discriminant :

calculer le discriminant:
=b2-4*a*c ;
Déduire les solutions:
si le discriminant est positif,
l’équation a 2 racines réelles:
X1=(-b-)/(2*a)
et
X2=(-b+)/(2*a)
 si le discriminant est nul,
l’équation a une racine double:

X=-b/(2*a)

 si le discriminant est
strictement négatif, l’équation
n’a pas de racine réelle.
L’algorithme 3 décrit les
solutions à l’aide des
instructions simples est
plus précises.
Variables
Définition: Une variable est une donnée
dont la valeur peut être modifiée, qui
possède un nom et un type et qui peut
être rangée en mémoire.

Un nom de variable doit commencer par

une lettre et doit être composé de
lettres, de chiffres et du caractère de
soulignement « _ » (les espaces ne sont
pas autorisés!) .

L'ensemble des symboles utilisables est

donc:
{0,1,2,...,9,A,B,...,Z,_,a,b,...,z}
 Variables (suite)
C distingue les majuscules et les minuscules, ainsi:

Nom_de_variable est différent de

nom_de_variable

La longueur des identificateurs n'est pas définie.

Variables (suite)
Identificateurs corrects Identificateurs incorrects

nom12 1nom
nom_20 nom.2
Nom_de_variable Nom de variable
deuxieme_choix deuxième_choix
mot_francais mot_français
Mots réservés
Les noms suivants ne peuvent pas être déclarés comme
noms de variables. Ce sont des noms réservés du
langage C.

auto break case char const

continue default do double else
enum extern float for goto
if int long register return
short signed sizeof static struct
switch typedef union unsigned void
volatile while
Type de Signification Taille Plage de
données (Algorithme) (octet) valeurs
acceptée
char caractère 1 (code ASCII)
int entier 4 -2147483648 à
2147483647
unsigned entier non 4 0à
int signé 4294967295
short entier court 2 -32768 à
32767
Type de Signification Taille Plage de
données (Algorithme) (octet) valeurs
acceptée
unsigned Entier court non 2 0 à 65535
short signé
long int entier long 4 -2 147 483 648
à 2 147 483 647
unsigned entier long non 4 0 à 4 294 967
long int signé 295
float réel simple 4 -3.4*1038 à
précision 3.4*1038
double réel double 8 -1.7*10308 à
précision 1.7*10308
Déclaration des variables
En notation algorithmique, une variable se
déclare de la façon suivante:

Nom_variable : type ;

ou bien s'il y a plusieurs variables du même

type:

Nom_variable1, Nom_variable2, ... : type ;

Déclaration
Exemple : des variables

resultat, moyenne: de type

réel;
i, j: de type entier;
Déclaration des variables
En langage C, une variable se déclare de la
façon suivante:

type Nom_variable;

ou bien s'il y a plusieurs variables du même

type:

type Nom_variable1, Nom_variable2, ...;

Déclaration des variables
Exemple :

float resultat, moyenne

int i, j;
char c;
float x, y;
Structure générale d’un algorithme
Un algorithme se compose:
 d’une partie déclaration dans laquelle nous
précisons les noms de variables et leurs
types.

 d’une partie instructions (une suite

d’instructions) encadrée par les mots clés «
Début » et « Fin ».
Structure générale d’un algorithme
Algorithme nom
Partie déclaration;
Début
Suite d’instructions;
Fin

Dans la partie déclaration, on déclare toutes les

variables utilisées dans l’algorithme.
Instruction d’affectation
L’affectation est l’action (l’opération) qui consiste
à affecter une valeur à une variable. En notation
algorithmique, elle et définie par :

variable  valeur;
Exemple :
x  1;
On affecte la valeur 1 à la variable x
 le contenue de la variable après l’affectation est
égal à 1.
 Instruction d’affectation

En langage C, on utilise l'opérateur

d'affectation "=" :

Nom_variable = donnée;

Exemple :
x = 1;
Il est nécessaire de déclarer la variable en lui
affectant un type. Par exemple:
float x;
 Initialisation des variables
En C, il est possible d’initialiser des variables lors
de la déclaration. L’initialisation se fait de la
façon suivante:
type Nom_variable = donnee;
Exemple :
int i = 2;
float x = 10.3;
char c = 'A';
Déclaration des constantes
Définition : Une constante est une variable
dont la valeur ne change pas le long du
programme.
En C, une constante est définit de la façon
suivante :
#define nom_constante valeur
Exemple :
#define Pi 3.1415927
Dans tout le programme, Pi sera remplacé par
3.1415927
Déclaration des constantes (suite)
Remarque :
Les constantes définies par #define ne sont pas
typés (n’ont pas de type).
Pour, déclarer des constantes typés, on ajoute
le mot clés const devant le type de la variable
qu'on veut utiliser comme constante.
Exemple :
const float pi = 3.1415927;
dites quelles seront les valeurs des variables
a,
b et c, après l’exécution de chacune des
instructions :
a = 5
b = 3
c = a + b
a = 2
c = b - a
Qu’obtiendra-t-on dans les variables a et b,
après exécution des instructions suivantes
(dans cet ordre) ?
a := 5
b := a + 4
a := a + 1
b := a - 4
Instruction A B

A=1 1 à la Programmation.pdf-
S'initier

B=A+3 1 4

A=3 3 4
 Qu’obtiendra-t-on dans les variables a et b,
après exécution des instructions suivantes
(dans cet ordre) ?
a := 5
b := a + 4
a := a + 1
b := a - 4
Qu’obtiendra-t-on dans les variables n1 et n2
après exécution des instructions ?
n1 = 5
n2 = 7
n1 = n2
n2 = n1
Même question avec les instructions :
n1 = 5
n2 = 7
n2 = n1
n1 = n2
Que font ces instructions ?
entier n, p, q
n = 5
p = 5
q = n / (n-p)
Que font ces instructions ?
entier n, p
n = 10
p = 4
n = n * p ;
p = n / p
Soient deux variables a et b déclarées par :
caractère a, b
Écrire les instructions permettant d’échanger
leur contenu.
Les opérateurs
Définition : Les opérateurs sont des symboles
qui permettent de manipuler des variables,
c'est-à-dire effectuer des opérations, les
évaluer, ...
On distingue plusieurs types d'opérateurs:
les opérateurs de calcul
les opérateurs d'affectation
les opérateurs d'incrémentation
les opérateurs de comparaison
les opérateurs logiques
Les opérateurs de calcul
Les opérateurs de calcul permettent de modifier
mathématiquement la valeur d'une variable.
L'opérateur d'affectation "=" :
Permet d'affecter une valeur à une variable.
Exemple :
x = 10.2;
i=2;
Il est possible d'enchaîner plusieurs opérations
d'affectations :
i = j = k = 3;
Les opérateurs de calcul (suite)
L'addition "+" :
Syntaxe
nom_var = expression1 + expression2 ;
Exemple :
x = y + 2; /* si y vaut 3, la valeur de x sera
5*/
z = x + y + 3;
Les opérateurs de calcul (suite)
La soustraction "-" :
Peut être utilisée de deux façons:
nom_var = - expression1;
nom_var = expression1 - expression2 ;
Exemple :
x = y - 2; /* si y vaut 3, la valeur de x sera
1*/
z = -(x + y + 3);
Les opérateurs de calcul (suite)
La multiplication "*" :
Syntaxe
nom_var = expression1 * expression2 ;
Exemple :
x = 2 * y ; /* si y vaut 3, la valeur de x sera
6*/
z = 4.5 * x * y;
Les opérateurs de calcul (suite)
La division "/" :
Syntaxe
nom_var = expression1 / expression2 ;
Remarque :
Si expression1 et expression2 délivrent des
valeurs entières, alors il s'agit d'une division
entière.
Si l'une des expressions, délivre une valeur
réelle, il s'agit d'une division réelle.
 La division (suite)
Exemple :
13/2 retourne 6
-13/2 et 13/-2 retournent –6.
13/2.0 retourne 6.5
Remarque :

x/(y + z) correspond à x
yz x/(y + z)  x/y +
x/y + z correspond à x  z z
y
Les opérateurs de calcul (suite)
Le modulo "%" :
Syntaxe
nom_var = expression1 % expression2 ;
Retourne le reste de la division de expression1
par expression2 (expression1 et expression2
doivent retourner des valeurs entières).
Si expression1 est un multiple de expression2
alors nom_var est égale à zéro.
Le modulo (suite)
Exemple :
13%2 retourne 1
-13%2 retourne -1
13%-2 retourne 1
8%2 retourne 0
Remarque :
Il faut que la valeur de b*(a/b) + a%b soit égale
à a.
Les opérateurs d'affectation
Souvent en retrouve des expressions de la forme :
x = x +2;
Avec les opérateurs d'affectation, cette
expression peut s'écrire sous la forme :
x += 2;
Le C associe à la plupart des opérateurs un
opérateur d'affectation de la forme "op="
Si exp1 et exp2 sont des expressions, alors
exp1 op= exp2 est équivalent à exp1 = exp1 op
exp2
Les opérateurs d'affectation (suite)
+= ajouter à (x += 3  x = x + 3)
-= diminuer de (x -= 3  x = x - 3)
*= multiplier par (x *= 3  x = x * 3)
/= diviser par (x /= 3  x = x / 3)
%= modulo (x %= 3  x = x % 3)
Remarques :
x *= y+2 signifie x = x*(y+2) et non x = x*y + 2
x /= y+2 signifie x = x/(y+2) et non x = x/y + 2
x -= y+2 signifie x = x-(y+2) et non x = x – y + 2
x %= y+2 signifie x = x%(y+2) et non x = x%y + 2
Les opérateurs d'incrémentation
Le langage C comporte deux opérateurs qui
permettent d'augmenter ou de diminuer des
variables d'une unité.
++ : opérateur d'incrémentation
-- : opérateur de décrémentation
x++ est équivalent à x += 1 ou bien x = x + 1
x-- est équivalent à x -= 1 ou bien x = x - 1
Les opérateurs de comparaison
Les opérateurs de comparaison sont :
< (inférieur)
<= (inférieur ou égal)
> (supérieur)
>= (supérieur ou égal)
== (égalité) (différent de = (affectation))
!= (différence, <> en notation
algorithmique)
Les opérateurs logiques
Les opérateurs logiques sont :
&& (et logique), || (ou logique) et ! (non
logique).

&& (et logique) : vérifie que toutes les

conditions sont réalisées
Syntaxe : condition1 && condition2
 condition1 && condition2 est vraie si les deux
conditions sont vraies et fausse sinon.
 condition2 n'est évaluée que si condition1 est
vraie.
Les opérateurs logiques (suite)
|| (ou logique) : vérifie qu'une des
conditions est réalisée
Syntaxe : condition1 || condition2
 condition1 || condition2 est vraie si l'une des
deux conditions est vraie et fausse sinon.
 condition2 n'est evaluée que si condition1 est
fausse.
Les opérateurs logiques (suite)
! (non logique) : inverse l'état d'une variable
booléenne
Syntaxe : !condition
 !condition est vraie si condition est fausse et
fausse sinon.
Les opérateurs logiques (suite)
Remarques :
1. Les résultats des opérations de comparaison
et des opérateurs logiques sont de type int :
• la valeur 1 correspond à vrai
• la valeur 0 correspond à faux

2. Les opérateurs logiques considèrent toute

valeur différente de zéro comme vrai et zéro
comme faux.
Les opérateurs logiques (suite)
Exemples :
32 && 2.3 donne 1
!65.34 donne 0
(4>3) || (2 > 1) donne 1
0||!(32 >12) donne 0
 Priorité
L'ordre des opérateurs
d'évaluation des différentes
parties d'une expression correspond
en principe à celui utilisé en
mathématiques.
 Priorité des opérateurs (suite)
Exemple :
Supposons pour l'instruction suivante: a=5, b=10,
c=1
x = 2*a+3*b+4*c;
L'ordinateur évalue d'abord les multiplications :
2*a  10 , 3*b  30 , 4*c  4
Après, il fait l'addition des trois résultats obtenus :
10+30+4  44
A la fin, il affecte le résultat général à la variable :
x = 44
Priorité des opérateurs (suite)
On dit alors que la multiplication a la priorité
sur l'addition et que la multiplication et
l'addition ont la priorité sur l'affectation.

Pour forcer l'ordinateur à commencer par un

opérateur avec une priorité plus faible, il faut
(comme en mathématiques) entourer le terme
en question par des parenthèses.
 Priorité des opérateurs (suite)
Exemple :
Dans l'instruction (pour a=5, b=10 et c=1) :
x = 2*(a+3)*b+4*c;
l'ordinateur évalue d'abord l'expression
entre parenthèses:
a+3  8
ensuite les multiplications:
2*8*b  160 et 4*c  4
ensuite l'addition:
160+4  164
enfin l'affectation :
x=164
Entre les opérateurs que nous connaissons
jusqu'ici, nous pouvons distinguer les classes
de priorités suivantes:
 Priorité Opérateurs Ordre d’évaluation
Priorité 1 (la () De l’intérieur ver
plus forte): l’extérieur
Priorité 2: ! ++ -- <--------
Priorité 3: */% --------->
Priorité 4: +- --------->
Priorité 5: < <= > >= --------->
Priorité 6: == != --------->
Priorité 7: && --------->
Priorité 8: || --------->
Priorité 9 (la = += -= *= /= %= <--------
plus faible):
Éliminer les parenthèses superflues dans les
expressions suivantes :
a = (x+5) /* expression 1 */
a = (x=y) + 2 /* expression 2 */
a = (x==y) /* expression 3 */
(a<b) && (c<d) /* expression 4 */
(i++) * (n+p) /* expression 5 */
a = x+5 /* expression 1 */
L’opérateur + est prioritaire sur l’opérateur
d’affectation =.
a = (x=y) + 2 /* expression 2 */
Ici, l’opérateur + étant prioritaire sur =, les
parenthèses sont indispensables.
a = x==y /* expression 3 */
L’opérateur == est prioritaire sur =.
a<b && c<d /* expression 4 */
L’opérateur && est prioritaire sur
l’opérateur <.
i++ * (n+p) /* expression 5 */
L’opérateur ++ est prioritaire sur * ; en
revanche, * est prioritaire sur +, de sorte
qu’on ne
peut éliminer les dernières parenthès
Les fonctions mathématiques
Le fichier "math.h" contient la déclaration des
fonctions mathématiques. Pour utiliser ces
fonctions, le programme doit contenir la ligne
:

#include <math.h>
(mettre avant main() )
Dans ce qui suit, x et y sont de type double et
toutes les fonctions retournent un double.
Pour les fonctions trigonométriques, les
angles sont exprimés en radians.
 Les fonctions mathématiques
(suite)

sin(x) : sinus de x
cos(x) : cosinus de x
tan(x) : tangente de x
asin(x) : arc sinus de x
acos(x) : arc cosinus de x
atan(x) : arc tangente de x
sinh(x) : sinus hyperbolique de x
cosh(x) : cosinus hyperbolique de x
tanh(x) : tangente hyperbolique de x
 Les fonctions mathématiques
(suite)

exp(x) : exponentielle de x (ex)

log(x) : logarithme népérien de x (ln(x), x>0)
log10(x) : logarithme à base 10 (log10(x), x>0)
pow(x,y) : x exposant y (xy ) (Il se produit une
erreur si x=0 et y0, ou si x<0 et y
n'est pas un entier)
sqrt(x) : racine carrée de x (x0)
fabs(x) : valeur absolue de x (|x|)
floor(x) : le plus grand entier inférieur ou égal à
x
ceil(x) : le plus petit entier supérieur ou égal à x
Les fonctions mathématiques (suite)
Exemple: (Algorithme)
Algorithme equation2
variable
a1, b3.2, c 2.1, delta, x1, x2:
de type réel;
Début
delta  b*b – 4*a*c;
x1  (–b – racine(delta))/(2*a);
x2  (–b + racine(delta))/(2*a);
Fin
Les fonctions mathématiques (suite)
Exemple :
#include<stdio.h>
#include<math.h>
main()
{
double a=1, b=3.2, c=2.1, delta, x1, x2;

delta = b*b – 4*a*c;

x1 = (–b – sqrt(delta))/(2*a);
x2 = (–b + sqrt(delta))/(2*a);
}
Commentaires
Lorsqu'un programme devient long et compliqué, il
est conseillé d'ajouter des lignes de
commentaires dans le programme, c'est-à-dire
des portions du fichier source qui ont pour but
d'expliquer le fonctionnement du programme
sans que le compilateur ne les prenne en compte.
Pour cela, il faut utiliser des balises qui vont
permettre de délimiter les explications afin que
le compilateur les ignore et passe directement à
la suite du fichier.
Ces délimiteurs sont :
/* et */
Un commentaire sera donc noté de la façon
suivante:
/*Voici un commentaire!*/
Commentaires (suite)
Il y a toutefois quelques règles à respecter:

• Les commentaires peuvent être placés

n'importe où dans le fichier source
• Les commentaires ne peuvent contenir le
délimiteur de fin de commentaire (*/)
• Les commentaires ne peuvent pas être
imbriqués
• Les commentaires peuvent être écrits sur
plusieurs lignes
• Les commentaires ne peuvent pas couper un
mot du programme en deux
Entrées/
sorties
 Affichage des données
La fonction printf est utilisée pour afficher du
texte et des données à l'écran. La syntaxe de
cette fonction est le suivant :
printf("format", arg1, arg2, …);
format : format de représentation.
arg1, arg2,… : variables et expressions dont les
valeurs sont à représenter.
 Format
La partie "format" est une suite de caractères qui
peut contenir :
du texte
des spécificateurs de format : suite de caractères
précédée du symbole %
des séquences d'échappement
Format (suite)
les formats de représentation indiquent la
manière dont les valeurs des expressions
arg1, arg2, … sont affichées.
la partie "format" contient exactement un
spécificateur de format pour chaque
expression arg1, arg2, …
 formats de printf
SYMBOLE TYPE AFFICHAGE COMME

%d ou %i int entier relatif

%u int entier naturel non signé
%f float, double rationnel en notation
décimale
%e ou %E float, double rationnel en notation
scientifique
%c int caractère
%s char* chaîne de caractères
%% (rien) %
 Exemple 1
#include<stdio.h>
main()
{
int i=3 , j=5;
printf("%d fois %d est %d", i, j, i*j);
}

Le programme précédent va afficher à l'écran :

3 fois 5 est 15

programme
 Exemple 2
#include<stdio.h>
main()
{
char c='A';
printf("le code de %c est %d", c, c);
}

Le programme précédent va afficher à l'écran :

le code de A est 65

programme
 Exemple 3
#include<stdio.h>
main()
{
double x=10.2, y=2.5;
printf("%f sur %f est %f", x, y, x/y);
}

Le programme précédent va afficher à l'écran :

10.200000 sur 2.500000 est 4.080000

programme
 Exemple 4
#include<stdio.h>
main()
{
double x=10.2, y=2.5;
printf("%e sur %e est %e", x, y, x/y);
}

Le programme affichera à l'écran :

1.020000e+01 sur 2.500000e+00 est 4.080000e+00

programme
 Séquences d’échappement
Le programme :

#include<stdio.h>
main()
{
printf("premier ");
printf("programme en C");
}
Affichera à l'écran :
premier programme en C programme
Pour afficher à l'écran :
Séquences d’échappement (suite)
premier
programme en C
en deux lignes, le programme précédent, devra
s'écrire comme suit:

#include<stdio.h>
main()
{
printf("premier \nprogramme en C");
}
programme
Séquences d’échappement (suite)
Les séquences d’échappement permettent
d'afficher des caractères non imprimables :
\n nouvelle ligne (new line)
\a déclenche un signal sonore (alarme)
\\ \ (back slash)
\t tabulation horizontale
\’ apostrophe
\" guillemet
Saisie des données
La fonction scanf permet de lire des données à
partir du clavier. Sa syntaxe est le même que
celui de printf :
scanf("format", &var1, &var2, …);
Les noms des variables, sont précédés du
symbole &.
Ils sont les mêmes que ceux de printf, avec la
Spécificateurs de format de scanf
différence d'utiliser :

"%lf", "%le" ou "%lE" pour les variables de type

"double".
 Exemple 1
#include<stdio.h>
main()
{
int i , j;
scanf("%d%d", &i, &j);
printf("i=%d et j=%d", i, j);
}

Permet de lire deux entiers et de les afficher à

l'écran. programme
 Exemple 2
#include<stdio.h>
main()
{
float x;
double y;
scanf("%f%lf", &x, &y);
printf("x=%f et y=%f", x,y);
}

Permet de lire deux réels (le premier simple et le

deuxième double) et de les afficher à l'écran.
programme
 Entrées/Sortie en algorithmique
Lire(var1, var2,….); permet à l’utilisateur de saisir
au clavier des valeurs (données) de mêmes types
que les variables var1, var2, …

Les valeurs saisies sont affectées respectivement

aux variables var1, var2, …
Afficher(var1, var2,….); permet d’afficher à l’écran,
les valeurs des variables var1, var2, …

Afficher(valeur); permet d’afficher à l’écran une

constante (valeur) sur l’écran.

Remarques:
 Une valeur chaîne de caractères s’écrit entre
deux quottes "
Exemple "ceci est une chaîne"

 Une valeur caractère s’écrit entre deux

apostrophes
Exemple ’a’ désigne la constante caractère a
Exercice :
1. Ecrire les instructions (en algorithmique) qui
 Lit deux valeurs réelles et les affectent aux
variables a et b
 Affiche la somme et le produit des deux valeurs
saisies.
2. Traduire l’algorithme en langage C
Solution :
1. Algorithme:
Algorithme produit_somme
variable
a, b : de type réel;
s, p : de type réel;
Début
Afficher (" entrer deux réels ");
Lire(a, b);
s  a+b;
p  a*b;
Afficher("La somme est ", s , " le produit est
", p);
Fin
2. Programme :
#include<stdio.h>
main()
{
float a, b;
float s, p;
printf("entrer deux réels ");
scanf("%f%f", &a, &b);
s = a+b;
p = a*b;
printf("La somme est %f , le produit est %f ",
s, p);
}
La commande :
Ecriture d'un caractère
putchar
permet d'afficher un caractère à l'écran.
Exemples :
int i=66;
char c='A';
putchar('a'); /* affiche le caractère a */
putchar(c); /* affiche le caractère A */
putchar(i); /* affiche le caractère B */
putchar('\n'); /* retour à la ligne */
Lecture d'un caractère
La commande :
getchar
permet de saisir un caractère du clavier.

Il faut taper le caractère et comfirmer par

"Entrée".

Les commandes getch et getche fournissent

immédiatement le prochain caractère entré
au clavier.
Exemple
#include<stdio.h>
main()
{
char c;
printf("Tapez un caractère :");
c = getchar();
printf("Voici le caractère que vous avez
tapé :");
putchar(c);
}
programme
Structures de
contrôle
Introduction
On appelle structure de contrôle les
instructions qui permettent de tester si une
condition est vraie ou non.

Ces structures peuvent être associées à des

structures qui se répètent suivant la
réalisation de la condition.
Une instruction est une expression suivie
La notion de bloc
d'un point-virgule.
x = 1.2;
i++;
Un bloc est un ensemble d'instructions
comprises entre des accolades ({ et }).

{
i++;
j--;
x = 3.4;
}
La notion de bloc (suite)
Un bloc est équivalent à une instruction. Donc,
on peut mettre un bloc là ou on peut mettre
des instructions.
Structure conditionnelle

Soit à calculer le maximum de 2

réels
a et b.

 Si (a > b) alors le maximum est a.

 Si (a < b) alors le maximum est b.
 Si (a=b) alors le maximum est a ou
b.
 Le résultat dépend de la valeur
de l’expression logique qui est la
comparaison de a et b.
La structure conditionnelle ou
alternative est une instruction de
contrôle qui permet de choisir les
instructions à exécuter suivant la
valeur d’une expression logique
(une condition):

Une condition est une expression

logique qui retourne une valeur
booléenne (vrai ou faux).
 Forme Si… Sinon … FinSi
Soit C une condition. On appelle instruction
conditionnelle ou alternative l’instruction
composée de la forme:
Si C alors {
bloc1 d’instructions;
}
Sinon {
bloc2 instructions;
}
FinSi
Où Si, Sinon et FinSi sont des mots clés
Interprétation:
Tout d’abord l’expression logique C
est évaluée :

 Si la valeur de C est "vrai" (on dit

que la condition C est vérifiée) alors
on exécute le bloc1 d’instructions.
 Sinon (c’est-à-dire si C n’est pas
vérifiée) alors c’est le bloc2
d’instructions qui sera exécuté
Exemple:
Ecrire les instructions qui calculent
le maximum et le minimum de
deux réels.
 a, b : de type réel;
max, min : de type réel;
Si (a > b) alors {
max  a;
min  b;
}
Sinon {
max  b;
min  a;
}
FinSi
L'instruction if-else (si-sinon)
En langage C, la forme Si… Sinon … FinSi se
traduit par la forme if-else. La syntaxe de if-
else est la suivante :

if (condition){
suite d'instructions 1
}
else {
suite d'instructions 2
}
L'instruction if-else (suite)
Comme pour la forme Si… Sinon … FinSi, si
condition est vraie, on exécute la suite
d'instructions 1, sinon (c'est à dire condition
est fausse), c'est la suite d'instructions 2 qui
est exécutée.
Remarques
 la condition doit être entre des parenthèses
 s'il n'y a qu'une instruction, les accolades
ne sont pas nécessaires
 il est possible de définir plusieurs
conditions à remplir avec les opérateurs ET
et OU (&& et ||)
par exemple:
1. if ((condition1)&&(condition2)) teste si les
deux conditions sont vraies
2. if ((condition1)||(condition2)) exécutera les
instructions si l'une des deux conditions est
vraie
Exemple:
Traduire (en langage C) les
instructions qui calculent le
maximum et le minimum de deux
réels.
 float a, b;
float max, min;

if (a > b) {
max = a;
min = b;
}
else {
max = b;
min = a;
}
Exercice
1. Ecrire un algorithme qui permet de saisir
trois réels a, b et c et de calculer
l'expression : d = a/(b*c)
2. Traduire l'algorithme en langage C
Solution (Algorithme)
Algorithme division
variable
a, b, c, d : de type réel;
Début
Afficher (" entrer trois réels ");
Lire(a, b, c);  si ( b*c = 0)
Si ((b = 0) ou (c = 0) ) alors {
Afficher("Division impossible");
}
Sinon {
d  a/(b*c);
Afficher(d);
}
FinSi
Fin
Solution (Programme C)
#include<stdio.h>
main()
{
float a, b, c, d ;
printf (" entrer trois réels "); if ( b*c == 0)
scanf ("%f%f%f", &a,&b,&c) ;
if ( (b == 0) || (c == 0) )
printf("Division impossible\n");
else{
d = a/(b*c);
printf("%f sur %f * %f = %f\n",a,b,c,d);
}
}
Forme Si … FinSi
Si le bloc2 d’instructions est vide (il
n’y a pas d’instruction à exécuter)
alors l’instruction conditionnelle a
la forme suivante:

Si C alors {
bloc1 d’instructions;
}
FinSi
L'instruction if
En langage C, la partie else est facultative.

if (condition){
suite d'instructions
}
Exercice
1. Ecrire un algorithme qui permet de saisir
deux réels et de calculer leurs maximum et
leurs minimum sans utiliser le mot clés
Sinon (forme Si .. FinSi).
2. Traduire l'algorithme en langage C
 Solution (Algorithme)
Algorithme Max_Min
variable
a, b, max, min : de type réel;
Début
Afficher (" entrer deux réels ");
Lire(a, b);
max  b;
min  a;
Si (a > b) alors {
max  a;
min  b;
}
FinSi
Afficher (" max = ", max, " min = ",
min);
Fin
 Solution (Programme C)
#include<stdio.h>
main()
{
double a, b, max, min;
printf (" entrer deux réels ");
scanf ("%lf%lf", &a,&b) ;
max = b;
min = a;
programme
if (a > b) {
max = a;
min = b;
}
printf("max = %f min =%f", max, min);
}
ifs imbriqués
Un if peut lui même contenir un autre if en tant
qu'instruction. Comme la partie else est
facultative, le else s'associe au if le plus
proche qui n'a pas de else.
Exemple :
if(n>0)
if (a>b)
max = a;
else
max = b;
ifs imbriqués (suite)
Dans l'exemple, le else correspond au
deuxième if (if (a>b)).
 Pour n=1, a=3 et b=2 on aura max=3
 Pour n=1, a=3 et b=4 on aura max=4
 Pour n=0, quelque soit les valeurs de a et b,
max n'est pas défini.
Si on veut que le else correspond au premier if, il
ifs imbriqués (suite)
faut utiliser des accolades :

if(n>0){
if (a>b)
max = a;
}
else
max = b;
Pour n=1, a=3 et b=2 on aura max=3
Pour n=0, a=3 et b=2 on aura max=2
Pour n=1, a=2 et b=3, max n'est pas défini
Remarque
Pour éviter toute confusion lors de l'utilisation de
plusieurs if, il faut mettre automatiquement des
accolades.
Exemple :

if(n>0){
if (a>b)
max = a;
else
max = b;
}
L'instruction else-if
La combinaison de plusieurs if-else, aboutit à la
construction suivante :

if (condition1)
bloc 1
else if (condition2)
bloc 2

else if (condition K)
bloc K
else
bloc K+1
L'instruction else-if (suite)
Les conditions sont évaluées du haut vers le
bas. Si une des conditions est vraie, le bloc
correspondant est exécuté et la séquence se
termine.
Le dernier else correspond au cas ou toutes les
conditions sont fausses. Il peut être omise.
Exemple
if (A > B)
printf("%d est plus grand que %d\n", A, B);
else if (A < B)
printf("%d est plus petit que %d\n", A, B);
else
printf("%d est égal à %d\n", A, B);

programme
Choix selon des valeurs
La construction de choix permet de construire
une instruction complexe de la forme :

selon expression
valeur1 : bloc1 d’instructions
valeur2 : bloc2 d’instructions

autrement : bloc d’instructions
fin selon
dont le fonctionnement est le suivant :
 l'expression est tout d'abord calculée et doit
avoir un résultat de type entier ou caractère
 valeur1, valeur2 … doivent être des
expressions constantes
 si le résultat du calcul donne une des valeurs
prévues, alors les instructions correspondantes
sont exécutées,
 si le résultat du calcul donne une valeur qui
n'était pas prévue, les instructions associées au
cas autrement sont exécutées. Le cas
autrement est facultatif.
Exemple
Cette construction est pratique pour
l’algorithme suivant, dans lequel on suppose
que la variable jour contient un entier
compris entre 1 et 7 représentant le jour de
la semaine du lundi au dimanche.
L'algorithme affiche en toutes lettres le nom
du jour correspondant.
Algorithme choix_jour
Variable
jour: de type entier
Début
Ecrire("donner un numéro")
Lire(jour)
selon jour
1 : Ecrire("Lundi")
2 : Ecrire("Mardi")
3 : Ecrire("Mercredi")
4 : Ecrire("Jeudi")
5 : Ecrire("Vendredi")
6 : Ecrire("Samedi")
7 : Ecrire("Dimanche")
autrement : Ecrire("Erreur")
fin selon
Fin
L'instruction switch
Pour traduire la construction selon en langage
C, il suffit de combiner l'instruction switch,
avec des instructions break :

switch (expression) {
case étiquette1: suite d'instructions
break;
case étiquette 2: suite d'instructions
break;
case étiquette...: suite d'instructions
break;
default: suite d'instructions
}
Remarques
étiquette1, …, étiquette n, doivent être des
expressions constantes.
Lorsque l'expression testée est égale à une
des valeurs suivant un case, la suite
d'instructions qui suit celui-ci est exécuté.
Le mot clé break indique la sortie de la
structure conditionnelle.
Le mot clé default précède la suite
d'instructions qui sera exécutée si
l'expression n'est pas égale à une des valeurs.
Attention: si on omet l'instruction break,
après exécution du cas choisi, les instructions
des cas suivants seront exécutées.
 Traduction de l'algorithme choix_jour
#include<stdio.h>
main()
{
int jour;
printf("donner un numéro\n");
scanf("%d",&jour);
switch (jour)
{
case 1 : printf("Lundi");break;
case 2 : printf("Mardi");break;
case 3 : printf("Mercredi");break;
case 4 : printf("Jeudi");break;
case 5 : printf("Vendredi");break;
case 6 : printf("Samedi");break;
case 7 : printf("Dimanche");break;
default : printf("Erreur");
}
}
programme
Exemple
scanf("%d",&n);
switch(n){
case 0:
printf("n=0 \n");
break;
case 1: case 2: case 3:
printf("0 < n < 4 \n");
break;
default :
printf("n < 0 ou n >3 \n");
}
programme
Les boucles
Les boucles permettent de faire
exécuter plusieurs fois les mêmes
instructions. Elles s’arrêtent
lorsqu’une certaine condition est
vérifiée.
On appelle parfois ces structures
instructions répétitives ou bien
itérations.
Les boucles
Pour l’écriture d’un algorithme on utilise les
formes suivantes:
 tant que
 faire … tant que
 pour

Le langage C dispose de :
 while (tant que)
 do while (faire … tant que)
 for (pour)
Boucle "Tant Que"
Soit C une expression logique, appelée
condition d’arrêt ou test de sortie, le schéma
"Tant Que" a la forme suivante:

Tant Que C Faire {

Instructions;
}
FinTQ
Interprétation:
On évalue la condition d’arrêt C

1. Si elle n'est pas vérifiée (la valeur de C est

"fausse") alors l’itération s’arrête
 on passe à l’exécution de l’instruction se
trouvant juste après le mot clés FinTQ

2. Si elle est vérifiée (la valeur de C est "vraie")

alors on répète l’exécution du corps de la boucle.
Remarques:
a. Il faut s’assurer que la boucle se termine

b. A la sortie de la boucle (à la fin d’exécution de

la boucle) la condition C vaut "faux".

c. Si, initialement la valeur de C est "Faux"

alors le corps de la boucle ne sera jamais
exécuté.
Exemple: calculer la somme S des n premiers
entiers positifs avec n≥1.
S=1+2+…+k+…+n

On a:
S(k)=S(k-1)+k, pour 1≤k≤n
avec S(0)=0

 La somme S est calculer de manière itérative

k, n, S: de type entier;
S  0; /* S(0) */
k  1;
Tant Que (k  n) Faire {
S  S+k; /* S=S(k) à l’étape k */
k  k+1;
}
FinTQ
Afficher(S,k);
Sa syntaxe est la suivante:
L'instruction while
while (condition) {
suite d'instructions
}
condition est une expression logique ou numérique.
Tant que condition est vraie (ou différent de zéro),
la suite d'instructions est exécutée.
La suite d'instructions est exécutée zéro ou
plusieurs fois.
Exemple
Calcule de la somme des n premiers entiers
positifs avec n≥1 (S=1+2+…+k+…+n)

int k, n, S;
S = 0; /* S(0) */
k = 1;
while (k <= n) {
S = S+k; /* S = S(k) à l’étape k */
k = k+1;
}
programme
Exemple
/* affiche les nombres de 10 à 1*/
i = 10;
while (i>0){
printf("%d\n",i);
i--;
}

programme
Exemple 2
/* affiche les nombres de 0 à 9*/
i = 0;
while (i<10){
printf("%d\n",i);
i++;
}

programme
Exemple 3
scanf("%d",&i);
while (i<10){
printf("%d\n",i);
i++;
}
Remarque :
Si la valeur saisie est supérieur ou égale à 10,
aucun affichage ne sera fait.

programme
Boucle « Faire …Tant que »
On peut utiliser la boucle " Faire …tant que "
lorsqu’on connais que le corps de la boucle
sera exécuté au moins une fois.

Soit C une expression logique (appelée

condition d’arrêt). La boucle " Faire …Tant
que " a la forme suivante:

Faire {
instructions; /* corps de la boucle
*/
}
Tant que C;
Interprétation
Contrairement à la boucle "Tant
Que", le corps de la boucle est
exécuté au moins une fois, car le
test de sortie de la boucle est
effectué après.

On répète l’exécution du corps de

la boucle jusqu’à ce que C vaut
"vrai".
Exemple
calculer la somme des n premiers entiers
positifs, avec n ≥ 1.

k  1;
S  0;
Faire {
S S+k;
k  k+1;
}
Tant que (k <= n);
L'instruction do-while
Sa syntaxe est la suivante:

do{
suite d'instructions
}
while (condition)

condition est une expression logique ou

numérique.
La suite d'instructions est exécutée au moins
une fois.
Elle est répétée tant que condition est vraie (ou
différent de zéro).
Exemple
float x;
do {
printf("Donner un nombre entre 1 et 10
:");
scanf("%f", &x);
}
while (x<1 || x>10);
programme
Exemple
On peut aussi utiliser la construction do …
while pour afficher les entiers entre 0 et 9 de
la façon suivante :
#include<stdio.h>
main(){
int I = 0;
do
{
printf("%d\n", I);
I++;
}
while (I<10);
} programme
Boucle "Pour"
On utilise une boucle "Pour" lorsqu'on sait
le nombre d’itérations à effectuer.

Pour (cpt  val1 à val2, à pas de val)

Faire {
instructions; /* corps de la
boucle*/
}
FinPour
cpt est une variable de type entier qui désigne un
compteur.

val1 est une valeur entière qui initialise le

compteur.

val2 est une valeur entière qui désigne la dernière

valeur que peut prendre le compteur.

val est une valeur entière qui désigne le pas

d’incrémentation du compteur.
Remarques
La boucle s’arrête si: cpt – val2 >
0

L’incrémentation du compteur
(cpt cpt+val) s’effectue de
manière implicite à la fin
d’exécution de chaque itération.
Exemple
calculer la somme des n premiers
entiers positifs, avec n≥1.

S  0;
Pour (k  1 à n, à pas de 1) Faire {
S S+k;
}
FinPour
Afficher(k,S);
Remarque
Lorsque le "pas" d’incrémentation
vaut 1, dans ce cas la boucle "Pour"
peut s’écrire sous la forme:

Pour (cpt  val1 à val2 ) Faire {

instructions; /* corps de la
boucle*/
}
FinPour
Exemple
calculer la somme des n premiers
entiers positifs, avec n≥1.

S  0;
Pour (k  1 à n) Faire {
S S+k;
}
FinPour
La boucle for
Sa syntaxe est la suivante:
for (exp1; exp2; exp3) {
suite d'instructions
}
est équivalent à :
exp1;
while (exp2) {
suite d'instructions
exp3;
}
La boucle for (suite)
exp1 est évaluée une fois avant le passage de la
boucle.
Elle est utilisée pour initialiser les données de la
boucle.
exp2 est évaluée avant chaque passage de la
boucle.
Elle est utilisée pour décider si la boucle est
répétée ou non.
exp3 est évaluée à la fin de chaque passage de la
boucle.
Elle est utilisée pour réinitialiser les données de la
boucle.
Exemple
calculer la somme des n premiers
entiers positifs, avec n≥1.
#include <stdio.h>
Exemple
main()
{
int k, n, S;
printf("Donner un entier : ");
scanf("%d", &n);

S=0;
for(k=1; k<=n; k++)
S = S+k;

printf("S=%d ",S);
}
programme
 Exemple
(Affichage des nombres de 0 à 9)
Algorithme :
Pour (i  0 à 9) Faire {
Afficher(i);
}
FinPour

Traduction :
/* affiche les nombres de 0 à 9 */
for(i=0; i<10; i++)
printf("%d\n",i);
programme
 Exemple
Affichage des carrées des nombres impairs de
1 à 30

Algorithme :
Pour (i  1 à 30, à pas de 2) Faire {
Afficher("le carrée de", i, " est ",i*i);
}
FinPour
Traduction :
for(i=1; i<=30; i+=2)
printf("le carrée de %d est %d\n",i,i*i);
programme
Exercice :
1. Ecrire un algorithme qui permet
d'afficher les carrées des nombres
pairs de 1 à n (n saisi au clavier), en
utilisant la boucle :
a) pour.
b) tant que.
2. Traduire l'algorithme en langage C
Solution :
(a) boucle pour
Algorithme carres_paire_pour
variable
i, n : de type entier;
Début
Afficher("Saisir un entier");
Lire(n);
Pour (i  2 à n à pas de 2) Faire {
Afficher("le carrée de", i, " est ",i*i);
}
FinPour
Fin
(a) boucle for
#include<stdio.h>
main(){
int i, n;

printf("Saisir un entier");
scanf("%d",&n);

for(i=2; i<=n; i+=2)

printf("le carrée de %d est %d\n",i,i*i);
}
Programme
(b) boucle tant que
Algorithme carres_paire_TantQue
variable
i, n : de type entier;
Début
Afficher("Saisir un entier");
Lire(n);
i  2;
Tant Que (i<=n) Faire{
Afficher("le carrée de", i, " est ",i*i);
i  i + 2;
}
FinTQ
Fin
(b) boucle while
#include<stdio.h>
main(){
int i, n;

printf("Saisir un entier");
scanf("%d",&n);
i = 2;
while(i<=n){
printf("le carrée de %d est %d\n",i,i*i);
i += 2;
}
}
Programme
Exercice :
1. Ecrire un algorithme qui permet de calculer la
factorielle N! = 123…(N-1)N d'un
entier naturel N saisi au clavier (0!=1), en
utilisant la boucle :
a) pour.
b) tant que.
2. Traduire l'algorithme en langage
C
Solution :
(a) boucle pour
Algorithme factorielle_pour
variable
i, N, fact : de type entier;
Début
Afficher("Saisir un entier");
Lire(N);
fact  1;
Pour (i  1 à N) Faire {
fact fact*i;
}
FinPour
Afficher(fact);
Fin
(a) boucle for
#include<stdio.h>
main(){
int i,N,fact;
printf("Saisir un entier");
scanf("%d",&N);
fact = 1;
for(i=1;i<=N;i++)
fact *= i;
printf("%d! = %d\n",N,fact);
}
(b) boucle tant que
Algorithme factorielle_tant_que
variable
i, N, fact : de type entier;
Début
Afficher("Saisir un entier");
Lire(N);
fact  1;
i  1;
Tant Que(i<=N) Faire{
fact  fact*i;
i  i + 1;
}
FinTQ
Afficher(fact);
Fin
(b) boucle while
#include<stdio.h>
main(){
int i,N,fact;
printf("Saisir un entier");
scanf("%d",&N);
fact = 1;
i=1;
while(i<=N){
fact *= i;
i++;
}
printf("%d! = %d\n",N,fact);
}
Exercice :
1. Ecrire un algorithme qui calcule nm, (n et m
saisis au clavier) avec m>0, en utilisant la
boucle :
a. pour.
b. faire…tant que
c. tant que.
2. Traduire l'algorithme en langage
C
(a) algorithme
Algorithme puissance_pour
variable
i, n, m, res : de type entier;
Début
Afficher("Saisir n et m");
Lire(n,m);
res  1;
Pour (i  1 à m) Faire
res  res*n;
FinPour
printf(n, " exposant ", m, " est ", res);
Fin
(c) programme C
#include<stdio.h>
main(){
int i, n, m, res;
printf("Saisir n et m");
scanf("%d%d",&n,&m);
res = 1;
for(i=1;i<=m;i++)
res *= n;

printf("%d exposant %d est %d\n",n,m,res);

}
Programme
Solution :
(a) algorithme
Algorithme puissance_tant_que
variable
i, n, m, res : de type entier;
Début
Afficher("Saisir n et m");
Lire(n,m);
res  1;
i  1;
Tant Que (i<=m) Faire {
res  res*n;
i  i+1;
}
FinTQ
Afficher(n, " exposant ", m, " est ", res);
Fin
(a) programme C
#include<stdio.h>
main(){
int i, n, m, res; /*res = n^m*/
printf("Saisir n et m");
scanf("%d%d",&n,&m);
res = 1;
i=1;
while(i<=m){
res *= n;
i++;
}
printf("%d exposant %d est %d\n",n,m,res);
}
Programme
(c) algorithme
Algorithme puissance_faire_tant_que
variable
i, n, m, res : de type entier;
Début
Afficher("Saisir n et m");
Lire(n,m);
res  1;
i  1;
Faire{
res  res*n;
i  i+1;
}
Tant que(i<=m);
Afficher(n, " exposant ", m, " est ", res);
Fin
(b) programme C
#include<stdio.h>
main(){
int i, n, m, res;
printf("Saisir n et m");
scanf("%d%d",&n,&m);
res = 1;
i=1;
do{
res *= n;
i++;
}
while(i<=m);
printf("%d exposant %d est %d\n",n,m,res);
}
Programme
Les tableaux
Imaginons que dans un programme, nous ayons
besoin simultanément de 12 valeurs (par
exemple, des prix pour calculer une somme).
On va déclarer douze variables, appelées par
exemple prixa, prixb, prixc, etc ou, par exemple
p1, p2, p3, etc.
Ecrire une succession de douze instructions
« Lire » distinctes
som ←
(p1+p2+p3+p4+p5+p6+p7+p8+p9+p10+
p11+p12)
:
Et si on ‘ a des milliers de variables à
traiter, ça va être fatiguant

la programmation nous permet de

rassembler toutes ces variables en une
seule, au sein de laquelle chaque valeur
sera désignée par un numéro.
Un ensemble de valeurs portant le même
nom de variable et repérées par un
nombre, s’appelle un tableau.

Le nombre qui, au sein d’un tableau, sert

à repérer chaque valeur s’appelle l’indice..
Dans la plupart des langages, on dispose de la
notion de tableau qui permet :
 d’attribuer un seul nom à l’ensemble de nos
douze valeurs, par exemple notes ;
 à repérer chaque note par ce nom et par un
numéro (ici entre 1 et 12).
Nous conviendrons que prix[1] désigne la
première valeur du tableau notes, que prix[3]
désigne la troisième, prix[8] la huitième, etc...
Plus généralement si i est une variable
entière dont la valeur est comprise entre 1 et
12, nous pourrons considérer
notes[i].
Voici un schéma illustrant la situation
 prix[1]
prix[3]

5 prix[i]

prix[12]
Ainsi, avec notre tableau prix, pourra-t-on
parler des variables indicées suivantes :
prix [i + 2]
prix [2 * i - 1]
à condition cependant que les valeurs des
expressions utilisées comme indice restent
bien comprises (ici) entre 1 et 12.
prix[1], prix[3] ou prix[i] se nomment souvent
des variables indicées
les valeurs entières servant de repère se
nomment des indices
Un élément de tableau est assimilable à une
variable
D’une manière générale, l’indice d’une
variable indicée peut être n’importe quelle
expression arithmétique entière.
Déclaration
Tout d’abord, nous conviendrons que tous les
éléments d’un tableau sont d’un même type
de base (entier, réel, caractère, booléen).
Par exemple, dans le tableau prix précédent,
tous les éléments pourraient être de type
réel.
Nous conviendrons de fournir cette information
à l’aide d’une instruction de déclaration telle
que :
tableau réel prix [20] // notes est un tableau de
20 éléments de type réel
Nous admettrons qu’il est possible de déclarer
plusieurs tableaux de même type, dans une
même instruction :
tableau entier t[30], x[5] // t est un tableau de 30
entiers, // et x est un tableau de 5 entiers
 Manipulation des éléments
d’un tableau

une variable indicée s’utilise comme une

variable simple. Elle peut donc faire l’objet

 d’une affectation,
 figurer dans une expression arithmétique,
 figurer dans la liste d’une instruction de
lecture ou d’écriture.
Affectation de valeurs à des
éléments d’un tableau
tableau entier x [4]
les instructions :
x[1]  12
x[2]  2
x[3]  15
x[4]  9
placent respectivement les valeurs 12, 2, 15
et 9 dans chacun des éléments du tableau x
caractère voyelle [6]
début
voyelle [1] ’a’
voyelle [2] ’e’
voyelle [3]  ’i’
voyelle [4]  ’o’
voyelle [5]  ’u’
voyelle [6]  ’y’
fin
 place dans le tableau nommé voyelle les six caractères
correspondants aux 6 voyelles :

a e i o u y
La syntaxe d’un tableau en langage C:
Type_éléments
Nom_tableau[Nombre_éléments]

-Type_éléments: le type des éléments

du tableau.
-Nom_tableau : le nom qui identifie le
tableau dans le programme.

Nombre_éléments: le nombre
d’éléments du tableau.
Exercices
Réécrivez les algorithmes précédents
en langage C
Déclarer un tableau de 5 entiers, un
tableau de 20 caractères, un tableau
de 100 nombres réels en simple
précision et un tableau de 100
nombres réels en double précision.
Lecture des éléments d’un tableau
Soit tableau entier x [4]
on pourra lire une valeur pour son premier
élément par :
lire (x[1])
De même :
Lire( x[1], x[3])
lira deux valeurs entières qui seront affectées
respectivement au premier et au troisième
élément du tableau x.
Il est possible de lire des valeurs pour chacun
des éléments de x en utilisant une répétition
appropriée :
répéter pour i  1 à 4
lire (x[i])
Écriture des éléments d’un tableau
tableau entier nombre [6]
i:entier
nombre [1]  0
répéter pour i  2 à 5
nombre [i]  1
nombre [6]  2
répéter pour i  1 à 6
écrire nombre ([i])
0
1
1
1
1
2
Utilisation de variables indicées
dans des expressions
k:entier
tableau entier a[6], b[6]
écrire («donnez 6 entiers : »)
répéter pour k  1 à 6
lire (a [k])
répéter pour k  1 à 6
b[k]  a [k] + 1
répéter pour k  1 à 6
écrire (b [k])
donnez 6 entiers : 8 5 10 3 20 1
 9
6
11
4
21
2
Exercice 7.1: Quels résultats fournira ce
programme ?
tableau entier nombre [5]
i:entier
répéter pour i  1 à 5
nombre [i] := i * i
répéter pour i  1 à 5
écrire nombre [i]
Exercice 7.2: Quels résultats fournira ce
programme ?
tableau entier c [6]
i:entier
répéter pour i  1 à 6
lire (c[i])
répéter pour i  1 à 6
c [i]  c [i] * c [i]
 répéter pour i  1 à 3
écrire (c [i])
répéter pour i  4 à 6
écrire (2*c[i])

lorsqu’on lui fournit en données les valeurs : 2,

5, 3, 10, 4 et 2
Exercice 7.3 Que fournit ce programme ?
tableau entier suite [8]
suite [1]  1
suite [2]  1
répéter pour i  3 à 8
suite [i]  suite [i-1] + suite [i-2]
répéter pour i  1 à 8
écrire suite ([i])
Initialisation d’un tableau à une
dimension
Nous écrivons ses différentes valeurs, placées
entre accolades ({ et }) et séparées par des
virgules

tableau entier t[5]  { 20, 30, 25, 15, 7}

tableau caractère voyelles[6]  {’a’, ’e’, ’i’,
’o’, ’u’, ’y’}
En langage C

Type_éléments Nom_tableau[taille]={
valeur_1,valeur_2,…
valeur_n};
Indiquer les éléments de chacun
des tableaux suivants, ainsi que
leur nombre:

int tab1[4]={ 2,3,5,7,11};

int tab2[ ] ={ 0,2,4,6,8};
int tab3 [100]={ 1};
 Le tableau tab1 contient 5 éléments
qui sont 2,3,5,7 et 11.

 Le tableau tab2 contient 5 éléments

qui sont 0,2,4,6, et 8.

 Le tableau tab3 contient 100 éléments.

Le premier élément de tab3 est 1 et les
autres sont tous égaux à 0.
Découvrir les erreurs dans les
déclarations suivantes:

int [5]={ 2,3,5,7,11};

int a[3]={10,20,40,60,80};
int s[-4];
int t[]4,7]
 1ère déclaration: le nom du tableau n’est
pas indiqué.
 2ème déclaration: le nombre de valeurs
dans la séquence d’initialisation dépasse
le nombre des éléments indiqué(qui est
3).
 3ème déclaration: le nombre des éléments
d’un tableau ne doit pas être négatif.
 4ème déclaration: le nombre des éléments
d’un tableau ne doit pas être un nombre
avec une virgule.
Propriétés d ’accés
Soit X un tableau d’un certain type T de
N éléments:
X[i]: désigne l’élément du tableau X
d’indice i
Les indices d’un tableau de N éléments
vont de 0 à N-1
X[i] est manipulé comme une variable
simple de type T. On peut lui appliquer
toutes les opérations possibles sur le
type T
On ne peut pas affecter un tableau
à un autre( l’affectation globale
est impossible en C). Il faut donc
effectuer cette affectation
élément par élément
On veut affecter le tableau a au
tableau b. Quelles sont les erreurs
dans les instructions suivantes:

int a[5]={1,2,3,4,5};
int b[5],i;
b=a;
for(i=1;i<=5;i++) b[i]=a[i];
 L’instruction b=a est fausse, car
l’affectation globale entre tableaux
est impossible en C.

 L’instruction for va réaliser

l’affectation du tableau a au tableau b
élément par élément. Mais l’indice de
début et l’indice de fin ne sont pas
correctes. Il faut écrire for(i=0;i<5;i+
+) b[i]=a[i];
Exercice1
écrire un programme qui déclare
un tableau de 100 entiers et qui
l’initialise par les nombres
entiers de 1 à100.
 Algorithme tableau test
tableau a[99] en entiers
début
Variable i en entier
Pour i  0 à 99
a[i] i+1
i suivant
Finpour
finprogramme
#include< stdio.h>
main()
{
int a[100];
int i;
for(i=0;i<100;i++)
a[i]=i+1;
}
écrire un programme qui permet
de saisir 20 nombres réels en
simple précision et les stocker
dans un tableau.
Algorithme <saisie_tab>
Début
tableau a[19] en réels simple précision
variable i en entier
pour i  0 à 19
Ecrire (a[i]=)
Lire(a[i])
isuivant
Finpour
finporgramme
#include< stdio.h>
main()
{
float a[19];
int i;
for(i=0;i<20;i++)
{
printf("a[%d]= “,i);
scanf("%f “,&a[i]);
}
}
écrire un programme qui permet de ranger
2,3,5,11,13,17 et 19
Dans un tableau et affiche ces éléments sur
une seule ligne.
#include< stdio.h>
main()
{
Int tab[ ]={2,3,5,7,11,13,17,19 };
int i;
for(i=0;i<8;i++)

printf("%d\t “,a[i]);
}
Propriétés de la taille d’un tableau en C

La taille (ou le nombre d’éléments) d’un

tableau doit être de type int ou un type
compatible à ce type. Elle est définie:

 Soit par une constante numérique.

 Soit une constante définie par le
macro #define.
 Soit une constante symbolique définie
par le mot-clé const.
 Soit une expression symbolique
 Quelle est le nombre des éléments de
chacun es tableaux suivants:

#define N 10
const int k=5;
int a[15];
int b[N];
char c[K];
float d[2*N];
double e[N+K+1];
 Le tableau a à pour taille 15 (taille
définie par une constante numérique)
 Le tableau b à pour taille 10 (taille
définie par un macro #define)
 Le tableau c à pour taille 5 (taille définie
par une constante symbolique)
 Le tableau d à pour taille 20 (taille
définie par l’expression symbolique 2*N).
 Le tableau e à pour taille 16 (taille
définie par l’expression symbolique
N+K+1)
Introduction aux tableaux à deux
dimensions
Matière Matière Matière Matière
1 2 3 4

Mohamme 12 10 18 11
d
Driss 15 13 16 14
Fatima 14 16 17 15
il est possible de placer ces différentes valeurs
dans un tableau à deux dimensions.

• notes [1, 2] représentera la note de

Mohammed en Matière 2 ;
• notes [2, 3] représentera la note de Driss en
Matière 3
 notes [1, 2] notes [2, 3]

12 10 18 11
15 13 16 14
14 16 17 15
Déclaration
tableau réel notes [3, 4] // réservation d’un
tableau de 20 valeurs (3 x 4)

chaque élément sera repéré par deux

indices :
 le premier variant entre 1 et 3
 le second entre 1 et 4
Affectation de valeurs
Considérons ces instructions :
Tableau entier x [2, 3]
x [1, 1]  5
x [1, 2]  12
x [1, 3]  2
x [2, 1]  8
x [2, 2]  9
x [2, 3]  5
Lecture des éléments
Si l’on a déclaré un tableau x par :
tableau entier x [2, 3]
on peut lire une valeur entière
pour un de ses éléments par une
instruction telle que :
lire (x [1, 2])
5 12 2
8 9 5
Bien entendu, il vous sera possible
de lire des valeurs pour tous les
éléments de x en utilisant
des répétitions imbriquées :
répéter pour i  1 à 2
répéter pour j  1 à 3
lire (x[i, j])
Si, par exemple, nous exécutons ces
instructions en fournissant les données
suivantes :
10 20 30 40 50 60
nous obtiendrons

10 20 30
40 50 60
Notez bien que si nous inversons
l’ordre des répétitions en
écrivant :
répéter pour j  1 à 3
répéter pour i  1 à 2
lire (x[i, j])
nous obtiendrons, avec les mêmes
données, un résultat différent

10 30 50
20 40 60
Écriture des éléments
Déclarer un tableau d’entiers de 2
dimension de taille [4,5], un
tableau de caractères de 2
dimension de taille [10,10].

Solution
int tab1[4][5];
char tab2[10][10];
Ecrire un programme qui demande
la saisie d’une matrice d’ordre 3
à coefficients entiers et qui
l’affiche ligne par ligne.
#include <stdio.h>
# define N 3
main()
{int tab[N][N];
int i,j;
Printf(`` saisie des coefficients de la matrice:\
n``);
For(i=0;i<N;i++)
For(j=0;j<N;j++)
{printf(``tab[%d][%d]=``,i,j);
Scanf(``%d``,&tab[i][j]);
}
Ecrire un programme qui saisit
deux matrices carrés d’ordre 4,
calcule leur somme et leur
produit et affiche les résultats
#include<stdio.h>
#define N 4
main(){
int a[N][N], a[N][N], s[N][N], p[N][N];
int i,j,k;
printf(‘’ saisie de la matrice a:\n’’);
for(i=0;i<N;i++)
for(j=0;j<N;i++)
{printf(‘’a[%d][%d]= ‘’,i,j);
scanf(‘’ %d‘’,&a[i][j]); }
printf(‘’ saisie de la matrice b:\n’’);
for(i=0;i<N;i++)
for(j=0;j<N;i++)
{printf(‘’b[%d][%d]= ‘’,i,j);
scanf(‘’ %d‘’,&b[i][j]); }
printf(‘’ calcul de la matrice s=a+b:\n’’);
for(i=0;i<N;i++){
for(j=0;j<N;i++)
{ s[i][j]=a[i][j] +b[i][j];
printf(‘’a[%d][%d]= ‘’,i,j); }
}
printf(‘’ calcul de la matrice p=a*b:\n’’);
for(i=0;i<N;i++)
{for(j=0;j<N;i++){
p[i][j]=0;
for(k=0;k<N;i++) p[i][j]+=a[i][k]+b[k]
[j];
printf(‘’p[%d][%d]= %d ‘’,i,j,p[i][j]);
}
}
}
 Chaîne de cacactères

Déclaration des chaînes de caractères

Une chaîne de caractères est traité et manipulée à
travers un tableau de caractères à une dimension.

La syntaxe en C d’une chaîne de caractères:

Char Nom[taille ]

Par la suite, on appellera une chaîne de caractères

chaîne ou string.
La taille d’un tableau ne peut pas être définie
par le nom d’une variable. Ainsi, les
déclarations suivantes ne sont pas correctes:
int N;
int tab1[N]; /*incorrecte*/
int K=10;
double tab2[K]; /* incorrecte*/
 Exemple

char ligne[13];
int i;
for(i=0;i<9;i++)
{
ligne[i]=‘a’+i; /* ‘a’+i accède au ième
caractère après ‘a’ */
}
ligne[9]=‘\0’;
Ces instructions permettront de remplir une
chaîne ligne caractère par caractère. En
suite, on place la caractère nul ‘\0’ de fin de
string.
 i 0 1 2 3 4 5 6 7 8 10 11 12

Ligne[i] ‘a’ ‘b ‘c’ ‘d’ ‘e’ ‘f’ ‘g’ ‘h’ ‘i’ ‘\0’ ? ?
’
Le caractère nul `\0`, est un caractère de
contrôle qu’il ne faut pas oublier. Il doit être
placé obligatoirement en fin de chaîne. Sans
lui la chaîne n’a pas de fin
 Initialisation de chaîne de caractères

char S[10]= ``bonjour !`` ;

`b` `o` `n` `j` `o` `u` `r` `` `!` `\0`

S[0] S[1] S[2] S[3] S[4] S[5] S[6] S[7] S[8]

`\0` est ajouté automatiquement par le compilateur car le nombre
de caractères dans ``bonjour !`` est < à la taille du tableau
 char S[ ]= {`b`,`o`,`n`,`j`,`o`,`u`,`r`,`\0`} ;

`b` `o` `n` `j` `o` `u` `r' `\0`

S[0] S[1] S[2] S[3] S[4] S[5] S[6] S[7]

Le tableau S est initialisé par le programmeur et `\0` est ajouté par
lui-même(le programmeur).
 Remarque

Si la taille de S <= à la taille de ``bonjour`` , ie

la taille de S <= 8 (7+1 de `\0`) selon le
compilateur, une erreur se produit pendant
la compilation ou l’exécution.
 Ecriture et lecture des chaînes

A coté des fonctions printf et scanf que nous

connaissons , il y’a des fonctions putchar et
getchar, puts et gets, spécialement conçues
pour l’écriture et la lecture de caractères et
de chaînes de caractères . Toutes ces
fonctions sont dans la librairie <stdio.h>
 Ecriture

char S[ 8]=``bonjour``;

printf(```%c``,S[0]); // affiche b

putchar(S[0]) // affiche b

printf(``%s``,S) // affiche bonjour

puts(S) // affiche bonjour

 Lecture
lecture d’un caractère

scanf(``%c``,&S[0]) getchar(S[0])

. lecture d’un string

scanf(``%s``,S) gets(S)
Quelques fonctions pour le taraitement
de chaînes

La librairie <string.h>fournit un grand

nombre de fonctions pratiques pour le
traitement de chaînes. Ces fonctions ayant
comme arguments des chaînes et retournant
comme résultat un entier ou une chaîne .
void*stract(char*chaîne1,char*chaîne2):
concatène les 2 chaînes , ajoute chaîne2 à la
fin de chaîne1; résultat dans chaîne1

void*strcpy(char*chaîne1,char*chaîne2):
copie la chaîne 2 dans la chaîne1, +’\0’ et
renvoie chaîne 1.
int strcmp(char*chaîne1,char*chaîne2): compare les
chaînes de caractères chaîne 1 et chaîne 2, renvoie
un nombre:

Positif si la chaîne 1 est supérieure à chaîne 2 (au

sens de l’ordre alphabétique)

négatif si la chaîne 1 est inférieure à chaîne 2 (au sens

de l’ordre alphabétique)

nul si les chaînes sont identiques.