Langage C

Universit Sidi Mohamed Ben Abdellah
Facult des Sciences et Techniques Fs

Dpartement Informatique
IEEA-TELECOM
Programmation en langage C
Zahi, Azeddine
2005-2006
Table des matires

Chapitre 0 : Introduction lalgorithmique............................................... 6
1. Introduction .................................................................................................... 6
1.1. Dfinition ............................................................................................. 6
1.2. Structure dun algorithme................................................................. 6
1.3. Dmarche mthodologique ................................................................ 7
2. Objets dun algorithme ................................................................................. 8
2.1. Identificateur....................................................................................... 8
2.2. Types prdfinis .................................................................................. 9
2.3. Dclaration........................................................................................... 9
2.4. Expressions ........................................................................................ 10
3. Instructions dun algorithme...................................................................... 11
3.1. Affectation ......................................................................................... 11
3.2. Lecture /criture ............................................................................... 12
3.3. Bloc dinstructions ............................................................................ 13
3.4. Choix .................................................................................................. 13
3.4.1. Choix sans alternative __________________________ 13
3.4.2. Choix avec alternative __________________________ 15
3.4.3. Choix imbriqu ________________________________ 17
3.4.4. Choix multiple_________________________________ 20
3.5. Rptition........................................................................................... 22
3.5.1. Prsentation des boucles ________________________ 22
3.5.2. Boucle tant que ________________________________ 22
3.5.3. Boucle rpter _________________________________ 26
3.5.4. Boucle pour ___________________________________ 29
Chapitre 1: Elments du langage C.......................................................... 32
1. Elments lexicaux......................................................................................... 32
1.1. Identificateurs ................................................................................... 32
1.2. Mots cls............................................................................................. 32
2. Structure dun programme C..................................................................... 32
2.1. Les commentaires ............................................................................. 33
2.2. Instructions........................................................................................ 33
A.Zahi/DI/FSTF
2.2.1. Instructions directement excutables ______________ 33

2.2.2. Instructions du prprocesseur____________________ 34
2.3. Fonctions............................................................................................ 34
2.4. Compilation dun programme C .................................................... 36
3. Variables et Types de base.......................................................................... 36
3.1. Types de base..................................................................................... 36
3.1.1. Les caractres _________________________________ 37
3.1.2. Les entiers ____________________________________ 37
3.1.3. Les rels ______________________________________ 37
3.2. Variables ............................................................................................ 38
3.2.1. Dclaration ___________________________________ 38
3.2.2. Initialisation __________________________________ 38
4. Les constantes............................................................................................... 39
4.1. Constantes littrales.......................................................................... 39
4.1.1. Constantes rels _______________________________ 39
4.1.2. Constantes entires_____________________________ 39
4.1.3. Constantes caractres___________________________ 40
4.1.4. Constantes chanes de caractres _________________ 40
4.2. Constantes symboliques ................................................................... 41
4.2.1. Pseudo-constantes______________________________ 41
4.2.2. Constantes variables____________________________ 41
5. Fonctions standards dentre/sortie........................................................... 42
5.1. Fonction printf .................................................................................. 42
5.2. Fonction sacnf ................................................................................... 43
5.3. Fonctions getchar() et putchar() ..................................................... 43
6. Expressions et Oprateurs .......................................................................... 44
6.1. Oprateurs arithmtiques................................................................ 44
6.2. Affectation ......................................................................................... 45
6.3. Incrmentation dcrmentation...................................................... 46
6.4. Oprateurs Logique.......................................................................... 47
6.5. Oprateur conditionnel .................................................................... 47
6.6. Expression.......................................................................................... 48
7. Structures de contrle ................................................................................. 48
7.1. Le choix .............................................................................................. 48
7.1.1. if sans else ____________________________________ 48
7.1.2. if avec else ____________________________________ 49
A.Zahi/DI/FSTF
7.1.3. Imbrication des tests____________________________ 50

7.1.4. Switch _______________________________________ 52
7.2. Boucles................................................................................................ 53
7.2.1. Boucle while __________________________________ 53
7.2.2. Boucle do while ________________________________ 55
7.2.3. Boucle for ____________________________________ 56
7.3. Instructions dchappement ............................................................ 58
7.3.1. Instruction break ______________________________ 58
7.3.2. Instruction continue ____________________________ 58
7.3.3. Instruction return______________________________ 59
7.3.4. Instruction exit ________________________________ 60
8. Les Pointeurs ................................................................................................ 60
8.1. Mmoire de lordinateur.................................................................. 60
8.2. Notion de pointeur ............................................................................ 61
8.3. Dclaration......................................................................................... 62
8.4. Initialisation....................................................................................... 62
8.4.1. initialisation laide de loprateur dadressage &___ 62
8.4.2. Initialisation laide de la fonction malloc ()________ 63
8.5. Indirection ......................................................................................... 63
8.6. Libration de lespace ...................................................................... 64
9. Les fonctions ................................................................................................. 65
9.1. Analyse descendante......................................................................... 65
9.2. Pseudo-fonction................................................................................. 66
9.3. Dclaration des fonctions utilisateur .............................................. 67
9.3.1. Prototype dune fonction ________________________ 67
9.3.2. Corps de la fonction ____________________________ 68
9.3.3. Comment obtenir une fonction ___________________ 69
9.4. Appel dune fonction ........................................................................ 69
9.4.1. Principe ______________________________________ 69
9.4.2. Syntaxe de lappel______________________________ 70
9.4.3. Passage des paramtres _________________________ 71
9.4.4. Port des variables _____________________________ 73
Chapitre 2: Tableaux et Chanes de caractres .................................. 76
1. Tableaux uni dimensionnels ....................................................................... 76
1.1. Dclaration......................................................................................... 76
1.2 Initialisation dun tableau................................................................ 77
1.3. Accs un lment du tableau ........................................................ 78
1.4. Pointeurs et Tableaux....................................................................... 79
1.4.1. Le nom dun tableau ___________________________ 79
1.4.2. Incrmentation et dcrmentation ________________ 80
A.Zahi/DI/FSTF
1.4.3. Indexation du tableau __________________________ 81

1.4.4. Tableaux dynamiques __________________________ 81
1.5. Tableau paramtre dune fonction................................................. 82
2. Tableaux de dimension deux ...................................................................... 84
2.1. Dclaration......................................................................................... 85
2.2. Initialisation....................................................................................... 85
2.3. Accs un lment............................................................................ 86
2.4. Tableau de dimension deux paramtre dune fonction ............... 87
3. Chanes de caractres .................................................................................. 89
3.1. Dclaration......................................................................................... 89
3.2. Initialisation....................................................................................... 89
3.3. Fonctions de manipulation .............................................................. 90
3.3.1. Affichage dune chane__________________________ 90
3.3.2. Saisie dune chane _____________________________ 91
3.3.3. Longueur dune chane _________________________ 91
3.3.4. Copie de chanes _______________________________ 92
3.3.5. Concatnation _________________________________ 93
3.3.6. Comparaison__________________________________ 93
Chapitre 3: Structures ..................................................................................... 95
1. Le mot cl typedef ........................................................................................ 95
2. Enumrations ............................................................................................... 96
2.1. Dfinition dune numration ......................................................... 96
2.2. Oprations sur les numrations .................................................... 97
3. Les Structures............................................................................................... 98
3.1. Dfinition dune structure ............................................................... 98
3.2. Dclaration......................................................................................... 99
3.3. Oprations sur les structures......................................................... 100
3.3.1. Accs aux membres ___________________________ 100
3.3.2. Initialisation _________________________________ 101
3.3.3. Affectation___________________________________ 102
3.4. Structure paramtre dune fonction ............................................ 102
3.5. Tableau de structures..................................................................... 104
3.6. Tableau membre dune structure................................................. 106
3.7. Structures imbriques .................................................................... 108
A.Zahi/DI/FSTF
Chapitre 4: Fichiers ....................................................................................... 110

1. Dfinition..................................................................................................... 110
2. Mmoire tampon........................................................................................ 110
3. Accs un fichier ....................................................................................... 111
3.1. Le type FILE* ................................................................................. 111
3.2. Ouverture/fermeture...................................................................... 111
4. Lecture /criture......................................................................................... 113
4.1. Lecture et criture par caractre.................................................. 113
4.2. Lecture et criture par chanes de caractres ............................. 114
4.3. Lecture et criture formates ........................................................ 114
4.4. Lecture et criture par blocs ......................................................... 117
5. Accs directe ............................................................................................... 118
A.Zahi/DI/FSTF
Chapitre 0 : Introduction
lalgorithmique
1. Introduction
1.1. Dfinition
Un algorithme est une notion qui remonte trs loin, Il prend ses racines
dans le mot "Algorisme" introduit par le mathmaticien Persse AlKhawarsimi
dans son livre " hisabo aljabri wa almoqabala". Ce nest donc pas une notion
propre linformatique.
Un algorithme sert dans la rsolution dun certain nombre de problmes
tels que : chercher le plus grand commun diviseur de deux entiers, rsoudre un
systme linaires, rsoudre une quation diffrentielle, trouver le chemin
optimal dans une ville, chercher une stratgie pour attaquer un march financier
etc. Il permet de dcrire le processus rsolution de faon prcise et non
ambigu ne laissant place ni linterprtation ni lintuition.
Un algorithme est considr comme une suite finie et ordonne dactions
lmentaires, instructions, effectues sur des donnes pour aboutir des
rsultats. En gnral, il y a plusieurs algorithmes (plusieurs solutions) qui
rsolvent le mme problme. Le meilleur algorithme (solution optimale) est celui
qui contient moins dinstructions.
Donnes
Algorithme
Rsultats
Figure 1 : Schma dun algorithme
1.2. Structure dun algorithme

Un algorithme est compos de deux parties :
Partie dclaration : contient les objets (donnes et rsultats) utiliss

pour rsoudre le problme.
Partie traitement : contient les instructions (actions) qui permettent de

rsoudre le problme.
A.Zahi/DI/FSTF
La forme gnrale dun algorithme se prsente comme suit:

algorithme nom_algorithme
constantes
Dclaration des constantes
types
Dclaration des nouveaux types
Partie dclaration
variables
Dclaration des variables
dbut
fin
Instructions
Partie traitement
Exemple
algorithme surface
constantes
PI = 3.14
rayon = 12.5
variables :
air : rel
dbut
air rayon*rayon*PI
ecrire(air)
fin
1.3. Dmarche mthodologique

Llaboration dun algorithme se droule selon les tapes suivantes :
La phase danalyse, consiste :
Identifier les paramtres qui dcrivent le problme i.e., les

paramtres qui constituent les donnes (ce quon a) et les
paramtres qui constituent les rsultats (ce quon cherche).
Formuler le problme en termes, de formules, dquations

mathmatique etc., et proposer des mthodes de rsolution en
termes de mthodes mathmatique ou de rgles de gestion.
La phase de conception, consiste :
Reprsenter les paramtres du problme par des objets

algorithmiques tels que les variables, les constantes, les structures
de donnes etc.
Exprimer les mthodes de rsolution sous forme dinstructions

algorithmique tels que les oprateurs, le choix, les boucles, les
fonctions etc.
A.Zahi/DI/FSTF
Exemple : Calculer le pgcd de deux entiers

Analyse
Entres : a, b deux entiers
Sorties : pgcd(a,b)
Mthode : lalgorithme dEuclide, pgcd(a,b)=pgcd(b,q)
Conception
Variables : a,b, et pgcd : entiers
Algorithme
r a mod b
tant que (r != 0) faire
a b
b a div b
r a mod b
fintantque
2.
Objets dun algorithme
Deux types dobjets sont utiliss pour reprsenter les paramtres dun
problme dans un algorithme: les constantes et les variables. Une variable est un
objet qui peut changer de valeur au cours de lexcution de lalgorithme, tandis
quune constante ne change jamais de valeur.
Un objet est caractris par :
Un identificateur qui permet de dsigner un objet dans lalgorithme.
Un type qui permet de dfinir lensemble des valeurs susceptibles

dtre prises par un objet ainsi que les oprateurs quon peut lui
appliquer.
Un tat qui correspond la valeur prise un instant de lexcution de

lagorithme.
2.1. Identificateur
Un identificateur permet didentifier un objet parmi les autres objets. Cest
une suite de caractres alphanumriques qui respecte les contraintes suivantes:
Un identificateur ne doit contenir que les caractres alphabtiques, les

chiffres et le caractre soulign " _",
Un identificateur doit toujours commencer par un caractre

alphabtique,
Un identificateur ne doit pas contenir les caractres accentus et

spciaux,
A.Zahi/DI/FSTF
Un identificateur doit reflter l'objet auquel il est associ. Par

exemple pour reprsenter le salaire d'un employ, il vaut mieux
choisir l'identificateur salaire.
Exemples
Identificateur valide
Salaire1
Etudiant
note_examen
Identificateur non valide

1salaire
tudiant
note dexamen
2.2. Types prdfinis

Les types prdfinis peuvent tre utiliss sans quils fassent lobjet dune
dclaration. Ces types sont : les entiers, les boolens, les rels et les caractres.
Entier : cest lensemble des entiers positifs, nuls ou ngatifs. Les

oprateurs applicables sont :
Boolen, un objet de ce type ne peut prendre que deux valeurs : VRAI ou

FAUX. Les oprations possibles sont :
Oprateurs logiques : et, ou et non.

Oprateurs de comparaison : = et .
Rel, ce type correspond lensemble des rels. Les oprations quon

peut appliquer sont :
Oprations arithmtiques: +, -, * /, div : division entire et mod :

reste de la division entire.
Oprations de comparaison: =, , <, , > et .
Oprations arithmtiques : +, -, * et /.
Oprations de comparaison : <, , >, , = et .
Caractre, regroupe le jeu de caractre d'une machine. Il est constitu par

les lettres (a, ..., z, A, ..., Z), les chiffres (0,1,...9) et les caractres spciaux
affichables sur l'cran et imprimable sur papier. Les oprations possibles
sont principalement les comparaisons : <, , >, , = et .
2.3. Dclaration
La dclaration dun objet dans un algorithme consiste lui attribuer un
identificateur et un type.
A.Zahi/DI/FSTF
10
Dclaration dune constante

Syntaxe
Identificateur_de_constante = valeur
Exemples
PI=3.14
TVA = 0.2
G =9.8
Dclaration dune variable

Syntaxe
Identificateur_de_variable : type
Exemples
i,n
x,y
exist
rep, c
: entier
: rel
: boolen
: carcatre
2.4. Expressions
Une expression est une combinaison de valeurs, de constantes, de variables
et doprateurs. Le type de lexpression est dfini par celui des objets qui la
constituent. Selon le type de lexpression on peut distinguer trois catgories
dexpressions : expression arithmtique, expression logique et expression de
chane de caractre.
Expressions arithmtique, ce sont des expressions formes par des

objets (valeurs, constantes et variables) entiers ou rels et des
oprateurs arithmtiques. Le rsultat de lexpression est un nombre
entier ou rel.
Exemples
n + 10 * cste /q
(a+b)*(c-d)/2
a div b
2*3.14*R
Expressions logiques : ce sont les expressions formes par des objets

(valeurs, constantes et variables) de type lmentaire et des oprateurs
logiques et de comparaison. Le rsultat de lexpression est boolen.
Exemples
( i<= n et exist = vraie)

( x != 1 ou y =0)
Formulation de la condition dadmission, des tudiants du Deug,

dans un tablissement en fonction de la moyenne gnrale (m) et
de lage dun tudiant (age).
(m > 12 et age <=24) ou (m >16 et age <26)
A.Zahi/DI/FSTF
11
3. Instructions dun algorithme

3.1. Affectation
C'est l'une des instructions les plus importantes en algorithmique. Elle
permet de ranger une valeur, une constante, le contenu dune variable ou le
rsultat dune expression, dans une variable.
Syntaxe
Nom_variable expression
Exemples
A 5
A B
A B+5
y ((n+10)*q)/t
cond_admis
(m
; avec
Nb_mod_val : le nombre de module valid et m la moyenne gnrale.
>=
10
et
Nb_mod_val
>
7)
Remarques
A gauche du symbole d'affectation il y a toujours une variable, les

instructions suivantes sont invalides :
A+5 3
15 C
PI 22/7
La variable gauche du symbole d'affectation et la valeur affecte

doivent tre de mme type, les instructions suivantes sont invalides :
A, B, C : entiers
A T
B " Bonjour"
C 12.5
On peut par contre affecter une expression entire une variable relle.
A : entier
B, C : rels
A 12
B A div 2
C= 15
Exercices
1. Ecrire un algorithme qui permet d'changer le contenu de deux
variables A, B.
2. Ecrire un algorithme qui permet de permuter les contenues de trois
variables A, B, C.
A.Zahi/DI/FSTF
12
3.2. Lecture /criture

L'instruction de lecture lire permet d'alimenter le programme par des
donnes partir de l'extrieur. Elle consiste lire une valeur sur le clavier et
laffecter ensuite une variable.
Syntaxe
lire (var1, var2,..., varn)
Exemple
algorithm lecture
variables
X :entier
Rayon : rel
C : caractre
debut
lire(X)
lire (rayon)
lire(c)
Fin
L'instruction d'criture crire permet dafficher sur un priphrique de

sortie, lcran priori, le rsultat dune expression. Lexpression peut tre
compose, une constante ou une variable.
Syntaxe
ecrire(exp1, ..., expn)
Exemples
algorithme ecriture
variables:
X :entier
Y :rel
Debut
Ecrire (" saisir la valeur de X")
Lire (X)
Y 2*X+1/X
Ecrire(" Valeur de Y = ", Y)
Fin
Exercices
1.
Ecrire un algorithme qui permet de saisir : le prix hors taxe PHT, le

nombre d'articles NART, le taux TVA, de calculer le prix PTTC et
dafficher :
PHT:
NBART :
TVA:
PTTC:
A.Zahi/DI/FSTF
13
2.
La surface dun triangle de cts a , b et c est donne par :

aire = S (S a )(S b )(S c ) , avec S =
(a + b + c ) .
2
Ecrire un algorithme qui calcule laire. On suppose quon dispose

dune fonction "racine2" qui calcule la racine carre dun nombre
rel.
3.3. Bloc dinstructions
Un bloc dinstructions est une suite dinstructions lmentaires dlimite
par les mots cls, Dbut et Fin, qui sexcutent squentiellement.
Exemple
Dbut
lire(x);
lire(y);
z x + y;
crire(z=,z);
Fin
3.4. Choix
Une instruction de choix permet de choisir, suivant une condition, entre
deux ou plusieurs blocs d'instructions. Le choix peut se prsenter sous plusieurs
formes: sans alternative, avec alternative, imbrique ou multiple.
3.4.1. Choix sans alternative
Syntaxe
Instr_avant_si
si (condition) alors
Bloc_instrs
finsi
Instr_aprs_si

Condition est une expression logique, si elle est vraie alors on excute
les instructions Bloc_instrs, sinon on passe aux instructions suivantes.
La figure 2 montre le fonctionnement de linstruction si sans sinon.
A.Zahi/DI/FSTF
14
Instr_avant_si
Condition
vraie
Bloc_instrs
fausse
Instr_aprs_si
Figure 2 : Organigramme de linstruction si sans sinon
Exemples
1. Calcul de la valeur absolue d'un nombre rel.
Algorithme absolue
variables:
X, Val_X :rel
Debut
Ecrire("saisir la valeur de X :")
Lire (X)
Val_X -X
si (X > 0) alors
Val_X X
finsi
Ecrire("valeur absolue de", X,"=", Val-X)
Fin
2. Calcul du maximum de deux entiers

Algorithme maximum
variables:
x, y, Max :entier
debut
Ecrire("saisir la valeur de X et Y :")
lire(X,Y)
Max x
si (x < y) alors
Max y
finsi
Ecrire ("Max (", X ",", Y, ")=", Max)
Fin
A.Zahi/DI/FSTF
15
Exercices
1. Ecrire un algorithme qui permet de saisir lentier n et le rel x et
dafficher la valeur de lexpression : ( 1)n * x .
2. Ecrire un algorithme qui saisit deux entiers et de les afficher dans lordre
dcroissant.
3. Ecrire un algorithme qui permet de saisir trois caractres et ne les
afficher que sils sont dans lordre alphabtique.
3.4.2.
Choix avec alternative
Syntaxe
Instr_avant_si
si (condition) alors
Bloc_vraie
sinon
Bloc_fausse
finsi
Instr_aprs_si

Condition est une expression logique si elle est vraie alors on

excute les instructions
Bloc_vraie, sinon on excute les
instructions Bloc_fausse, le choix dune alternative exclue lautre.
La figure 3 montre le fonctionnement de linstruction si avec sinon.
Instr_avant_si
fausse
Condition
Bloc_fausse
vraie
Bloc_vraie
Instr_aprs_si
Figure 3 : Organigramme de linstruction si avec sinon
A.Zahi/DI/FSTF
16
Exemples
1. Une droite est dfinie par deux points, A = (x1 , y1 ) et B = (x 2 , y 2 ) ,
lalgorithme ci-dessous saisit les points, A , B et P = (x , y ) , et dcide si le
point P appartient la droite ( AB ) .
Algorithme disible
variables:
x, y, xa, ya, xb, yb :rels
debut
Ecrire ("Saisir le point A")
lire(xa, ya)
Ecrire ("Saisir le point B")
lire(xb,yb)
Ecrire ("Saisir le point P")
lire(x,y)
si ((ya-y)*(xb-x) = (xa-x)*(yb-y) ) alors
ecrire("P appartient la droite")
sinon
ecrire("P nappartient pas la droite")
finsi
Fin
2. Lalgorithme suivant saisit deux entiers, x et y , et dcide si x est divisible

par y .
Algorithme divisible
variables:
x, y :entier
debut
Ecrire("Saisir
lire(x,y)
si (x mod y ==
ecrire(
sinon
ecrire(
finsi
Fin
x et y")
0 ) alors
x, "est divisible par", y)
x, "nest divisible par", y)
Exercices
1. Ecrire un algorithme qui saisit deux entiers, a et b , et qui affiche
lexpression b = a * q + r avec p et r le rsultat de la division entire de
b par a . Il faut prendre en considration la cas o b est divisible par a .
Exemples
15 = 7* 2 + 1
10 = 5*2
2. La fonction caractristique de un intervalle I = [a , b] est dfinie par :
1, si x I
. Ecrire un algorithme qui saisit un rel x et qui affiche
0, sinon
(x ) =
la valeur de (x )
3. Ecrire un algorithme qui saisit deux points, A = (x1 , y1 ) et B = (x 2 , y 2 ) ,

calcul et affiche la dviation de la droite ( AB ) par rapport laxe (Ox ) .
A.Zahi/DI/FSTF
17
4. Ecrire un algorithme qui saisit trois rels x , a et b et affiche limage de

x par la fonction, dfinie sur ( , b] , reprsente par le graphe suivant :
1
5. Trois nombres positifs peuvent reprsenter les cots dun triangle dans
la mesure o chacun dentre eux est infrieur la somme des deux
autres. Ecrire un algorithme qui saisit les trois nombres et affiche si on
peut construire un triangle avec.
3.4.3.
Choix imbriqu
Dans lun des blocs dune instruction de choix on peut avoir une
instruction qui contient une autre instruction de choix et ainsi de suite. On dit
dans ce cas que le choix est imbriqu.
Syntaxe
Instr_avant
si (condition_1) alors
si (condition_11) alors
.
.
sinon
.
finsi
sinon si (condition_2)
.
.
Sinon
.
.
finsi
finsi
Instr_aprs

Lexcution de cette instruction se base sur le fait quun sinon

correspond au si le plus proche.
Une reprsentation arborescente permet didentifier tous les cas

possibles et aussi dorganiser les diffrents choix. Etant donne un
problme dont le choix est reprsent par larbre suivant :
A.Zahi/DI/FSTF
18
C1
C5
C2
Bloc52
Bloc51
C3
Bloc2
F
Bloc3
C4
v
Bloc4
Figure 4 : Reprsentation graphique du choix imbriqu
La partie de lalgorithme correspondant se prsente comme suit :

si (c1) alors
si (c2) alors
si (c3) alors
Bloc3
sinon
si (c4) alors
bloc4
finsi
finsi
sinon
bloc2
finsi
sinon
si ( c5) alors
bloc51
sinon
bloc52
finsi
finsi
Exemple
Calcul du maximum de trois nombres entiers a, b et c saisir. La solution peut
tre reprsent par larbre suivant :
a>b
V
a>c
V
Max=a
b>c
F
Max= c
Max=b
Max= c
Figure 5 :Reprsentation graphique du max(a,b,c)
A.Zahi/DI/FSTF
19
algorithme maximum3
variables :
a,b,c,max : entier
debut
Ecrire (" Saisir a, b et c :")
lire(a,b,c)
si (a > b) alors
si (a > c) alors
max a
sinon
max c
finsi
sinon
si (b > c) alors
max b
sinon
max c
finsi
finsi
ecrire(max)
fin
Exercices
1. Soient a, b et c trois rels, crire un algorithme qui permet de rsoudre
dans IR lquation: a X2 + b X + c = 0. Etudier tous les cas.
2. Ecrire un algorithme qui permet de saisir cinq rels x , a , b , c , d , et
dafficher limage de x par la fonction reprsente par le graphe
suivant :
1
3. La mention de russite est attribue en fonction de la moyenne de

ltudiant selon le tableau suivant :
Moyenne
18 m
14 m <18
12 m <14
10 m <12
Mention
Trs Bien
Bien
Assez Bien
Passable
Ecrire un algorithme qui saisit la moyenne et

correspondante.
affiche la mention
4. Ecrire un algorithme qui permet de saisir deux rels, x et y , et

dafficher le nombre complexe associ sous la forme : z = x + iy . Etudier
tous les cas.
5. Ecrire un algorithme qui permet de saisir deux droites, ( AB ) et (CD ) ,
et dafficher si elles sont perpendiculaires, parallles ou colinaires.
A.Zahi/DI/FSTF
20
3.4.4.
Choix multiple
Si linstruction si- sinon finsi permet de choisir seulement entre deux

alternatives, l'instruction selon, par contre, permet de choisir entre plusieurs.
Syntaxe
Instr_avant_selon
selon (expr)
val_1
val_2
: Bloc_1
: Bloc_2
...
val_n
:Bloc_n
autrement : Bloc_a
finselon
Instr_aprs_selon

L'expression, expr, est value, si sa valeur est identique l'une des

valeurs val_1,...,val_n, alors le bloc d'instructions correspondant est
excut, sinon, cest le bloc correspondant la clause autrement qui
est excut.
La figure 6 montre lexcution de linstruction selon.

Instr_avant_selon
Evaluation de lexpression
val_1
val_2
Bloc_1
Bloc_2
val_n
Bloc_n
autrement
Bloc_a
Instr_aprs_selon
Figure 6 : Organigramme de linstruction selon
Exemple
Selon la couleur du feu de circulation, Rouge, Vert ou Jaune, un chauffeur
excute les oprations, Arrter, Avancer ou Ralentir, lalgorithme ci-dessous
permet de simuler le comportement du chauffeur. A chaque couleur on associe
un entier entre 0 et 2 et suivant la valeur saisie on excute l'action approprie.
A.Zahi/DI/FSTF
21
Algorithme Feu
variables:
Couleur: entier
debut
Ecrire (" Quel est la couleur
Lire (Couleur)
Selon (Couleur)
0
: Ecrire ("
1
: Ecrire ("
2
: Ecrire ("
autrement : Ecrire ("
finselon
Fin
du feu")
Arrter ")
Avancer ")
Ralentir ")
Feu en panne")
Exercices
1. Une exploitation agricole utilise un robot pour contrler la temprature
de ses serres. Selon le temps quil fait, Pleut, chaud, froid, beau, le
robot excute les oprations, Fermer la serre,
Dclancher le
ventilateur, Dclancher le chauffage, Ouvrir la serre.
Ecrire un algorithme qui permet de simuler le fonctionnement dun
robot.
2. Dans un magasin, le prix de vente dun produit est calcul par la
formule: Prix_ttc = prix_ht + (tva * prix_ht). Cinq classes de tva sont
dfinies selon lindice du produit.
Indice
1
2
3
4
5
tva
0
0.05
0.1
0.15
0.2
Ecrire un algorithme qui saisit le prix hors taxe prix_ht et lindice dun
produit indice, calcule et affiche le prix_tcc quivalent.
3. Un garagiste utilise un code pour chaque activit du garage. CODE=1
pour la vente des voitures neuves, CODE=2 pour la vente des voitures
doccasion, CODE=3 pour la vente des pices dtaches et CODE=4
pour la rparation des voitures. La commission dun employ est
calcule sur chaque activit de la manire suivante : sur une voiture
neuve, 2% du prix de vente mais avec un maximum de 5000DH, sur une
voiture doccasion, 5% du prix de vente mais avec un minimum de
500DH,sur les pices dtaches 6% du prix total et enfin sur la
rparation dune voiture 10% du prix de la main duvre.
Ecrire un algorithme qui saisit le code de lactivit et le prix
correspondant et qui affiche la commission.
A.Zahi/DI/FSTF
22
3.5. Rptition
3.5.1. Prsentation des boucles
Une boucle est une instruction qui permet de dcrire une rptition dans un
algorithme. Elle consiste rpter lexcution dun bloc dinstructions, appels
corps de la boucle, un certain nombre de fois, une excution du bloc sappelle
itration. Il existe trois formes de boucles : tant que, rpter et pour, chacune est
caractrise par les lments suivants :
Le bloc d'instructions rpter (corps),
Une condition darrt, c'est une expression logique qui permet l'arrt de
la boucle, une fois le nombre d'itrations est achev.
Le nombre d'itrations, deux cas de figure sont distingus :
3.5.2.
Le nombre d'itrations est connu lavance,
Le nombre d'itrations est inconnu priori, dans ce cas larrt

est dtermin par le corps de la boucle.
Boucle tant que
Syntaxe
Instr_avant
tant que (Condition)

faire
fintantque
Bloc
Instr_aprs

Condition est une expression logique, le bloc dinstruction est

excut jusqu ce que la condition devienne fausse.
La figure 7 montre l'excution de la boucle tant que.
A.Zahi/DI/FSTF
23
Instr_avant_tantque
Condition
vraie
Corps de la boucle
fausse
Instr_aprs_tantque
Figure 7 : organigramme de la boucle tant que
Comment raliser une boucle tant que ?

Selon la connaissance du nombre ditrations, trois cas se prsentent pour
la ralisation dune boucle tant que :
Premier cas : le nombre ditration est connu lavance. Dans ce cas nous
aurons besoin des lments suivants :
Un entier N qui reprsente le nombre d'itrations.
Un entier C, appel compteur, qui reprsente le numro de l'itration en

cours.
Linstruction, C Vin, qui permet linitialisation du compteur avec

une valeur initiale Vin.
Linstruction C C+1 qui permet lincrmentation du compteur aprs

chaque itration. Cette instruction doit tre insre dans le corps de la
boucle.
Lexpression logique, (C<= N + Vin -1), qui reprsente la condition

darrt de la boucle.
Ainsi, on obtient la partie de lalgorithme suivante:

C Vin
tant que (C <= N+Vin-1) faire
Bloc
C C+1
fintantque
A.Zahi/DI/FSTF
24
Exemples
n
1. Calculer la somme des n premiers entiers :
i
i =1
algorithme somme
variables :
n,s,i :entier
dbut
Ecrire ("Saisir n")
lire (n)
i 1
s 0
tantque(in) faire
s s+i
i i+1
fintantque
crire ("Somme=", s)
fin
2. Calcul du nombre dentiers infrieurs n qui sont divisibles par un

entier k donn.
algorithme combien
variables :
nb,n,k,i :entier
dbut
Ecrire ("Saisir n")
lire (n)
Ecrire ("Saisir k")
lire(k)
i 1
nb 0
tantque(in) faire
si (i mod k = 0)
nb nb + 1
finsi
i i+1
fintantque
crire ("le nombre est :", nb)
fin
Deuxime cas : le nombre ditrations nest pas connu et larrt de la boucle

est dcid par lutilisateur de lalgorithme. Pour cela on utilise une question,
du type "voulez-vous continuez oui/non ?", quon affiche aprs chaque
itration. L'utilisateur saisit ensuite sa rponse qui permet lalgorithme soit
de passer litration suivante, soit de mettre fin la boucle. Dans ce cas
nous aurons besoin des lments suivants :
Un caractre, Rep, qui permet de stocker la rponse de l'utilisateur
Linstruction, Rep "O", qui permet dinitialiser la variable Rep
Linstruction daffichage, ecrire(" texte de la question O/N"), qui

affiche la question pour utilisateur.
Linstruction de lecture, lire(Rep), qui saisit la rponse utilisateur.

A.Zahi/DI/FSTF
25
Lexpression logique, (Rep N), qui reprsente la condition darrt.

Rep "O"
tant que (Rep "N")
faire
Bloc
ecrire(" texte de la question
lire(Rep)
O/N"),
fintantque
Exemple
Un client achte plusieurs produits o chaque produit est caractris par la
quantit achete qa et son prix unitaire pu . Etablir l'algorithme qui calcul
et qui affiche le montant total payer par un client. Le montant d'achat d'un
seul produit est donn par la formule mp = qa * pu .
Algorithme client
Variables
Rep : caractre
MT, mp, pu : rel
Debut
MT 0
Rep '0'
Tant que ( Rep='O') faire
Lire(qa,pu)
Mp qa*pu
MT MT+mp
Ecrire("Un autre produit O/N")
Lire (Rep)
Fintant que
Fin
Troisime cas: le nombre ditrations est inconnu et larrt de la boucle est

dcid par lalgorithme lui-mme. Dans ce cas la condition darrt est
dtermine partir de lnonc du problme et de la mthode de rsolution
propose.
Exemple
Saisir une phrase caractre par caractre, la fin de la phrase est identifie par
le caractre .
algorithme saisir_phrase
variables :
c :caractre
dbut
lire (c)
tantque(c .) faire
lire (c)
fintantque
fin
A.Zahi/DI/FSTF
26
Exercices
1. Ecrire un algorithme qui calcul x n , avec x et n sont donns.
2.
Ecrire un algorithme qui calcul n! , avec n donn.
3.
Ecrire un algorithme qui calcul la somme de n entiers saisis au clavier.
4.
Soit la suite dfinie par :

x0 = 1
1
a
xn = 2 xn 1 + x
n 1
La suite (xn )n converge vers

valeur approche de
a , crire un algorithme qui calcul une
a.
Soit la suite dfinie par :
5.
F0 = 0, F1 = 1
Fn + 2 = Fn +1 + Fn
Ecrire un algorithme qui calcul le nme terme de la suite (Fn )n .
La suite Dn =
Fn +1
converge vers un nombre , appel nombre
Fn
dor, crire un algorithme qui calcul une valeur approch de .

6.
Dans un tablissement, les candidats au concours dentre au 2me cycle

sont slectionns sur la base de lge et de la moyenne gnrale du
DEUG. Lge doit tre infrieur 24 ans et la moyenne suprieure 12
et si lge est infrieur 26 ans la moyenne doit tre suprieure 16.
Ecrire un algorithme qui calcul le nombre de candidats slectionns.
7.
Ecrire un algorithme qui saisit un entier et qui affiche sa reprsentation

binaire.
3.5.3.
Boucle rpter
Syntaxe
Intsr_avant
rpter
Bloc
Jusqu (Condition)
Instr_aprs

Condition est une expression logique, le bloc dinstructions est

rpt jusqu ce que condition devienne vraie.
La figure 8 correspond l'excution de la boucle rpter.

A.Zahi/DI/FSTF
27
Instr_avant_repeter
Corps de la boucle
fausse
Condition
vraie
Instr_aprs_repeter
Figure 8 : Organigramme de la boucle rpter
Comment raliser une boucle rpter ?

Selon la connaissance du nombre ditrations, trois cas se prsentent pour
la ralisation dune boucle rpter:
Premier cas : le nombre ditrations est connu lavance. Dans ce cas nous
utilisons les mmes lments que ceux de la boucle tant que, seule la
condition darrt est diffre, elle devient (C > N + Vin -1). Ainsi, on
obtient la partie de lalgorithme suivante:
C Vin
rpter
Bloc
C C+1
Jusqu (C > N+Vin-1)
Exemples
n
1. Calcul de la somme des n premiers entiers :
i
i =1
algorithme somme
variables :
n,s,i :entier
dbut
Ecrire ("Saisir n")
lire (n)
i 1
s 0
rpter
s s+i
i i+1
Jusqu( i>n)
crire ("Somme = ", s)
fin
A.Zahi/DI/FSTF
28
2. Calcul du nombre dentiers < n qui sont divisibles par un entier k saisi.
algorithme combien
variables :
nb,n,k,i :entier
dbut
Ecrire ("Saisir n et k ")
lire (n, k)
i 1
nb 0
repter
si (i mod k = 0)
nb nb + 1
finsi
i i+1
jusqu (i>n)
crire ("le nombre est :", nb)
fin
Deuxime cas : le nombre ditrations nest pas connu et larrt de la boucle

est dcid par lutilisateur de lalgorithme. Dans ce cas aussi nous utilisons
les mmes lments que ceux de la boucle tant que, seule la condition darrt
diffre, elle devient (Rep = "N").
Rep "O"
rppter
Bloc
ecrire(" texte de la question
lire(Rep)
O/N"),
jusqu (Rep="N")
Exemple
Un client achte plusieurs produits o chaque produit est caractris par la
quantit achete qa et son prix unitaire pu . Etablir l'algorithme qui permet
de calculer et afficher le montant total payer par un client. Le montant
d'achat d'un seul produit est dfini par mp = qa * pu .
Algorithme client
Variables
Rep : caractre
MT, mp, pu : rel
Debut
MT 0
Rep '0'
rpter
Lire(qa,pu)
Mp qa*pu
MT MT+mp
Ecrire("Un autre produit a/N")
Lire (Rep)
Jusqu(Rep=n)
Fin
A.Zahi/DI/FSTF
29
Troisime cas: le nombre ditrations est inconnu et larrt de la boucle est

dcid par lalgorithme lui-mme. Dans ce cas galement la condition
darrt est dtermine partir de lnonc du problme et de la mthode de
rsolution propose.
Exemple
Saisir une phrase caractre par caractre, la fin de la phrase est identifie par
le caractre .
algorithme saisir_phrase
variables :
c :caractre
dbut
lire (c)
rpeter
lire (c)
jusqu( c=.)
fin
Exercices
Refaire les exercices de la page 23 en utilisant la boucle rpter.
3.5.4.
Boucle pour
Syntaxe
Instr_avant
pour i
allant de vi
faire
finpour
vf
Bloc
ou de faon gnrale
pour
i allant de
faire
Bloc
finpour
vi
vf incrment/dcrment
pas
Instr_aprs

vi, vf : valeur initial et valeur finale du compteur de la boucle.
Pas la valeur avec la quelle on incrmente ou on dcrmente le

compteur de la boucle chaque itration.
Dans cette dernire forme, le nombre d'itrations doit tre connu au

pralable, le compteur de la boucle est incrment / dcrment
automatiquement de la valeur pas.
La figure 9 correspond l'excution de la boucle Pour.

A.Zahi/DI/FSTF
30
Instr_avant_pour
I val_initiale
incrment
vraie
I <= val_finale
Corps de la boucle
fausse
Instr_aprs_pour
Figure 9 : Organigramme de la boucle pour
Exemples
1. Affichage des nombres pairs infrieurs n
algorithme pair
variables :
n,i :entiers
dbut
ecrire("saisir n")
lire (n)
pour i allant de 2 n incrment pas = 2
faire
ecrire (i)
finpour
fin
n
i
i =1
algorithme somme
variables :
n,s,i :entier
dbut
Ecrire ("Saisir n")
lire (n)
s 0
pour I allant de 1 n
faire
s s+i
finpour
crire ("Somme=', s)
fin
A.Zahi/DI/FSTF
31
Exercices
1. Ecrire un algorithme qui permet de calculer n! , n est saisi au clavier.
2. Ecrire un algorithme qui permet de calculer x n , n et x sont saisis au
clavier.
3. Ecrire un algorithme qui permet dafficher les entiers infrieurs n qui
sont divisibles par un entier k saisi au clavier. Donner les formes.
4. Ecrire un algorithme qui permet dafficher les diviseurs dun entier n
saisi au clavier.
5. On suppose quon ne dispose pas de loprateur *, crire un algorithme
qui permet de calculer le produit deux entiers.
6. Un triplet ( p , q , r ) dentiers naturels est dit pythagoricien si et seulement
si p 2 + q 2 = r 2 . Ecrire un algorithme qui permet dafficher tous les
triplets pythagoriciens ( p , q , r ) , avec, p et q < n , n saisi au clavier.
7. Ecrire un algorithme qui permet de calculer la valeur de la fonction
f n (x ) =
i =n
i!
, x et n saisis au clavier.
i =1
A.Zahi/DI/FSTF
32
Chapitre 1: Elments du langage C
1. Elments lexicaux
1.1. Identificateurs
Un identificateur est une suite de caractres alphanumriques, qui permet
de dsigne les objet dun programme, plus prcisment: les variables, les
constantes symboliques, les fonctions et les types construits par le
programmeur. Le choix dun identificateur doit obier aux rgles suivantes :
Un identificateur commence toujours par une lettre,
Un identificateur ne contient pas les caractres spciaux et accentus, le

caractre soulign _ est considr comme une lettre,
Un mot-cl nest pas un identificateur.
Les majuscules et minuscules sont diffrencies.
Au de l dune certaine longueur, gnralement 31 caractres, le

compilateur peut tronquer les identificateurs.
1.2. Mots cls

Un certain nombre de mots, appels mots cls, sont rservs aux
instructions du langage. Le tableau ci-dessous contient les 32 mots cls du
langage C quon peut classer en plusieurs catgories :
Catgories
spcificateurs de stockage
spcificateurs de type
qualificateurs de type
instructions de contrle
Divers
2.
Mots cls
auto, register, static, extern, typedef
char, double, enum, float, int, long, short,
signed, struct, union, unsigned, void
const, volatile
break, case, continue, default, do, else, for,
goto, if, switch, while
return, sizeof
Structure dun programme C
Un programme C est compos par des variables, des instructions et des

fonctions. La structure dun programme C se prsente comme suit :
A.Zahi/DI/FSTF
33
[directives de compilation]
[dclarations des variables globales]
[dclarations des fonctions]
void main()
{
dclarations des variables locales
Instructions
}
2.1. Les commentaires

Un commentaire est un texte mis entre les caractres /* et */. Il permet
de documenter un programme pour une meilleure lisibilit et une maintenance
facile (correction, modification etc.).
Exemples :
/* ceci est un commentaire */
/*/* ceci nest pas un commentaire
*/*/
2.2. Instructions
2.2.1. Instructions directement excutables
Instruction lmentaire : cest une expression termine par un point

virgule ( ; ).
expression ;
Instruction compose, cest une suite dinstructions lmentaires,

dlimite par des accolades {}, appele bloc. Elle permet de regrouper un
ensemble dinstructions sous la forme dune seule.
Exemple
/* Permutation des valeurs de a et b*/
void main()
{
int a=2 ;
int b=5 ;
int temp;
{
temp=b ;
b=a ;
a= temp ;
}
}
Remarques
Contrairement aux expressions, les instructions nont ni type ni valeur.

Lorsquon construit une instruction partir dune expression la valeur de
cette dernire est perdue.
Nimporte quelle expression peut former une instruction.

A.Zahi/DI/FSTF
34
2.2.2. Instructions du prprocesseur

Ce sont des instructions particulires appeles directives de compilation.
Elles permettent au compilateur deffecteur un pr-traitement sur le texte du
programme avant sa compilation. Une directive de compilation commence
toujours par le caractre #, les deux directives de compilation les plus
importantes sont :
La directive # define permet la dfinition des pseudo-constantes et des

pseudo-fonctions.
La directive # include permet linclusion dun fichier dextension .h,

appel fichier en-tte, dans le texte source du programme. Les fichiers
en-tte contiennent, gnralement la dclaration des constantes et des
fonctions. On distingue deux catgories de fichiers en-tte :
Les fichiers de la bibliothque qui sont inclus laide de

linstruction #include <en_tete.h>
Les fichiers construits par le programmeur qui sont inclus

laide de linstruction #include en_tete.h
Exemple
/* Inclusion du fichier dentres sorties standard*/
#include <stdio.h>
#include <stdlib.h>
/* definition dune pseudo-constante*/
#define PI 3.14
/* definition dune pseudo-fonction*/
#define CARRE(x) ((x)*(x))
void main()
{
int n=25 ;
float rayon ;
printf(donner le rayon du cercle) ;
scanf(%f, &rayon) ;
surface = PI*rayon *rayon ;
printf(S = %f , surface) ;
ptintf("carre de n = %d", CARRE(n)) ;
}
2.3. Fonctions
Lune des caractristiques du langage C est quil est compos par une ou
plusieurs fonctions. Une fonction est une entit indpendante forme par un
ensemble dinstructions et qui effectue une tche bien prcise, on distingue
trois types de fonctions :
A.Zahi/DI/FSTF
35
La fonction principale main():cest une fonction obligatoire dans tout

programme C, elle constitue le point dentre lors de lexcution dun
programme.
Les fonctions de la bibliothque, ce sont des fonctions fournies avec le

compilateur comme printf et scanf.
Les fonctions secondaires : ce sont des fonctions dfinies par le

programmeur.
Exemple : Surface dun cercle

#include <stdio.h>
#define PI 3.14
/* fonction secondaire qui permet de calculer la surface
dun cercle */
float calc_surface (float r)
{
float s ;
s= PI*r*r ;
return (s) ;
}
/* fonction principale */
void main()
{
float rayon, surface ;
/* fonctions de la bibliothque stdio.h */
printf( Rayon= ?) ;
scanf(%f, &rayon) ;
surface = calc_surface(rayon) ;
printf( Surface = %f\n, surface) ;
}
A.Zahi/DI/FSTF
36
2.4. Compilation dun programme C

Edition du texte
source
Editeur de texte
.cpp .c
format ASCII
Prprocesseur
Traitement des
directives de
compilation
Compilation et
gnration du code
objet
Compilateur
.obj
format binaire
Inclusion du
code objet des
fichiers inclus
Gnration du
code excutable
Editeur des liens
.exe
format binaire
Figure 10 : Processus de compilation en langage C
3. Variables et Types de base

3.1. Types de base
Le langage C est un langage typ i.e. chaque objet est associ un type qui
dfinit la reprsentation en mmoire et lensemble des valeurs quil peut prendre.
Les types de base en C concernent les caractres, les entiers et les rels.
A.Zahi/DI/FSTF
37
Un type est caractris par :
Un mot cl.
La taille de lespace mmoire, en octets, occupe par un objet de ce type.

Elle dpend en gnrale de la machine utilise.
Lensemble des valeurs susceptibles dtre prises par un objet.
3.1.1.
Les caractres
Le type caractre est dsign par le mot cl char, les valeurs prises par les
objets de ce type sont le jeu de caractres de la machine utilise. Chaque objet
est cod sur 1 octet.
3.1.2.
Les entiers
Les entiers peuvent tre affects de deux attributs :
Un attribut de prcision, dsign par short et long, permet de prciser la

reprsentation interne de lobjet en termes despace mmoire.
Un attribut de reprsentation, dsign par unsigned et signed, permet de

prciser lutilisation ou non du bit de signe.
Ces attributs peuvent tre combins pour former plusieurs types numriques :
Mot cl
Description
Valeur min
Valeur max
Taille en octets
Int
short int
long int
unsigned int
entier standard
entier court
entier long
entier standard non
sign
entier court non
sign
entier long non
sign
-32768
-32768
-2147483548
0
32767
32767
2147483547
65535
2 octets
2 octets
4 octets
2 octets
65535
2 octets
4294957295
4 octets
unsigned
short int
unsigned long
int
3.1.3.
Les rels
Les rels sont caractriss par leur prcision (nombre de chiffre aprs la
virgule). Le langage C dispose de trois types de rels suivant la prcision
dsire. Le tableau suivant montre leurs caractristiques.
Mot cl
Valeur min
Valeur max
Taille
float
double
long double
3.4*10-38
1.7*10-308
3.4*10-4932
3,4*1038
1.7*10308
1.1*104932
4 octets
8 octets
10 octets
A.Zahi/DI/FSTF
38
3.2. Variables
Une variable est un emplacement mmoire dont la valeur peut changer au
cours de lexcution du programme.
3.2.1.
Dclaration
Une variable doit faire lobjet dune dclaration avant toute utilisation. Ce la
consiste spcifier son type et son nom.
Syntaxe
type id1, id2,...,idn ;

type est lun des types de base, int, char, float, etc.
id1, id2,...,idn : la liste des identificateurs.
Exemples
int compteur,X1,X2;
float hauteur,largeur;
double masse_atomique;
char touche;
3.2.2.
Initialisation
En C il est possible dinitialiser une variable lors de sa dclaration,

linitialisation se fait suivant la syntaxe suivante :
Syntaxe
type identi = valeur ;
Exemple
void main()
{
int compteur = 0 ;
float hauteur = 3.14 ;
char Rep = O;
}
Remarque
Une variable peut tre dclare plusieurs niveaux dun programme : dans
un fichier externe, dans la fonction main, dans une fonction secondaire ou dans
bloc dinstructions.
A.Zahi/DI/FSTF
39
4. Les constantes
4.1. Constantes littrales
Cest une valeur qui apparat littralement dans le code source dun
programme, le type de la constante dpend de son criture.
4.1.1.
Constantes rels
Les constantes rels ou encore les constantes flottantes sont reprsents par
la notation mantisse-exposant, lexposant est dsign par la lettre e ou E.
Remarque
Une constante relle est par dfaut de type double. Pour la forcer avoir
une reprsentation sous forme dun float (resp. long double) on doit laffecte
de lattribut f ou f(resp. L).
Exemples
4.1.2.
Constante
type
15.25
15.2e-4
15.25f
15.25l
double
double
float
long double
Constantes entires
Les constantes entires peuvent sexprimer dans les systmes dcimal, octal
ou hexadcimal.
Notation dcimal : la constante est une suite qui commence par un chiffre
diffrent de 0, suivie de chiffres entre 0 et 9.
Notation octal : La constante est une suite qui commence par le chiffre
zro 0, suivie de chiffres entre 0 et 7.
Notation hexadcimal : la constante est une suite de caractres qui

commence par les caractres 0x et 0X, suivie de chiffres entre 0 et 9 et
de lettres entre a et f.
Remarque
Une constante entire est par dfaut de type int. Pour forcer la constante
avoir une reprsentation sous forme dun entier long : long int (resp court) on
doit laffecter de lattribut l ou L (resp. de u ou U).
A.Zahi/DI/FSTF
40
Exemples
4.1.3.
Constante
type
2001
02589
0x4D7
12458798L
1247U
12458798UL
int
int /*octal*/
int /*hxadcimal*/
long int
unsigned int
Unsigned long int
Constantes caractres
Les constantes de type caractre sont assimiles un entier sur un octet dont
la valeur correspond la position du caractre dans la table ASCII.
Les caractres imprimables : il suffit de mettre le caractre entre

apostrophes, par exemple a, A, c, $. Les seuls caractres
imprimables qui ne scrivent pas de cette manire sont : lantislash \ et
lapostrophe , qui scrivent : \\ et \.
Les caractres non imprimables: la constante est constitue de deux

caractres entre guillemets dont le premier est \, dans ce cas on lappelle
squence dchappement. Le tableau ci-dessous prsente la liste des
squences dchappement les plus utilises.
4.1.4.
Constante
Nom
\n
\t
\v
\b
\r
\f
\a
Retour la ligne
Tabulation horizontale
Tabulation verticale
Retour arrire
Retour chariot
Saut de page
Signal dalerte
Constantes chanes de caractres
Une constante chane de caractres est une suite de caractres entre

guillemets. En mmoire cette suite se termine par le caractre NULL \0.
Exemple
quoi quon dise quoi quon face
Les malheurs sont la ponctuation de la vie
Remarque
Il ne faut pas confondre a qui est une constante caractre et a qui est
une constante chane de caractres.
A.Zahi/DI/FSTF
41
4.2. Constantes symboliques

Une constante symbolique est un objet dont la valeur ne change pas au cours
de lexcution du programme. Elle est reprsente par un nom quon peut
utiliser chaque fois quon a besoin de la constante. Deux types de constantes
symboliques peuvent tre distingues.
4.2.1.
Pseudo-constantes
Cest une constante dont le nom est attribu par la directive #define. Le
prprocesseur remplace chaque occurrence du nom par la valeur de la constante
sans aucune vrification de type.
Syntaxe
#define IDENF val_subst

IDENF : Identificateur qui reprsente le nom de la constante.
val_subst: reprsente la valeur de la constante.
Exemple
#define PI 3.14159
#define G 9.81
void main()
{
float s,r =12.5;
float m=15;
s = PI*r*r ;
P = G * m ;
}
Remarque
Il est prfrable dutiliser des noms en majuscules pour dsigner les

constantes symboliques afin de les diffrentier des autres objets (variables
et fonctions).
La dfinition dune constante nest pas une dclaration, il ny a pas donc

de point virgule ; la fin.
4.2.2.
Constantes variables
Cest une constante dclare comme une variable dont on ne peut pas
modifier le contenu au cours du programme. Elle occupe donc un espace en
mmoire centrale.
A.Zahi/DI/FSTF
42
Syntaxe
const type id = valeur;

const : mot cl qui indique que id est une constante.
id : identificateur qui reprsente le nom de la constante.
type: lun des types de base.
valeur : valeur de la constante.
Exemple
void main()
{
float s,r=11.6;
const float PI=3.14
s= PI*r*r ;
}
5.
Fonctions standards dentre/sortie
La librairie standard <stdio.h> contient un ensemble de fonctions qui

permettent de communiquer avec lenvironnement extrieur. Lappel la
librairie <stdio.h> seffectue par la directive de compilation # include.
5.1. Fonction printf
La fonction printf() permet de transfrer le contenu dune variable, dune
constante ou le rsultat dune expression sur la sortie standard stdout, par dfaut
lcran. Cest une fonction dcriture formate i.e., les arguments pris comme
paramtres sont convertis selon le format spcifi.
Syntaxe
printf(format, expr1, expr2,..., exprn) ;

expr1, expr2, ..., exprn : les valeurs afficher.
format : une chane de caractres constitue par :
Le texte afficher.
Des squences dchappement pour le contrle de laffichage.
Des spcificateurs de format qui permettent dannoncer le

format avec lequel lexpression doit tre affiche. Pour chaque
expression on associe un spcificateur de format. Il est constitu
du symbole % suivie dun caractre qui indique le format
d'impression.
A.Zahi/DI/FSTF
43
Symbole
Type
Impression comme
%d ou %i
int
%u
int
%o
int
%x
int
%c
int
%f
double
%e
double
%s
char*
entier relatif
entier naturel (unsigned)
entier exprim en octal
entier exprim en hexadcimal
Caractre
rationnel en notation dcimale
rationnel en notation scientifique
chane de caractres
5.2. Fonction sacnf

La fonction scanf() permet de saisir des donnes partir du clavier et les
stocke aux adresses fournies comme arguments.
Syntaxe
scanf(format, &v1, &v2,..., &vn) ;

v1, v2,...,vn : les variables qui reoivent les donnes saisies,

ladresse de chaque variable est obtenue par loprateur &.
format cest une chane de caractres qui

contient les
spcificateurs de format de chaque variable comme pour la
fonction printf. Un spcificateur de format est constitu du symbole
% suivie dun caractre qui indique le format dans lequel la donne
saisie doit tre convertie.
Remarque
Les donnes saisies au clavier doivent tre spares par des espaces ou des
retour chariot, sauf sil sagit de la saisie dun caractre.
5.3. Fonctions getchar() et putchar()
Les fonctions getchar() et getchar() permettent respectivement de saisir et
dafficher des caractres.
Syntaxe
char c ;
c = getchar() ;
putchar(c) ;

La fonction getchar() retourne un int qui correspond au caractre lu.

Elle retourne lentier EOF, valeur dfinie dans stdio.h, qui
correspond la fin de lecture.
La fonction putchar() retourne un int qui correspond au caractre lu

ou la constante EOF, en cas derreur.
A.Zahi/DI/FSTF
44
Exemple
#include <stdio.h>
void main()
{
int c ;
while ((c = getch() != EOF)
putchar() ;
}
6.
Expressions et Oprateurs
Un oprateur est un symbole qui dcrit une opration ou une action

effectuer sur un ou plusieurs oprandes. Les oprateurs sont classs en quatre
classes :
6.1. Oprateurs arithmtiques
Il existe cinq oprateurs arithmtiques en C quon peut classer en oprateurs
binaires et unaires.
Addition, cest un oprateur la fois binaire et unaire (+ )
Soustraction, cest un oprateur la fois binaire et unaire (- )
Multiplication, cest un oprateur binaire (* )
Division, cest un oprateur binaire (/ )
Reste de la division entire, cest un oprateur binaire (% )
Syntaxe
expr1 op expr2 /*pour les oprateurs binaires*/
op expr /*pour les oprateurs unaires*/

expr1, expr2 et expr sont les oprandes. Pour les oprateurs +, -, *,

/ les oprandes peuvent tre des entiers ou des rels. Pour
loprateur % les oprandes sont toujours des entiers.
Exemple
Le programme C ci-dessous permet de lire un entier, un rel et dafficher
leur somme, leur diffrence et leurs produits:
A.Zahi/DI/FSTF
45
#include <stdio.h>
void main()
{
int nb ;
float re;
printf (donner nb et re : ) ;
scanf(%d %f, &nb, &re) ;
/* le rsultat dune opration entre un
rel est un rel */
printf (somme
: %f\n, (nb+re))
printf (diffrence : %f\n, (nb-re))
printf (produit
: %f\n, (nb*re))
}
entier et un
;
;
;
Remarque
Lorsque le type des deux oprandes nest pas le mme il y a conversion
implicite dans le type le plus fort. Soient x, y deux oprandes dun oprateur et
a,b leurs types, la conversion se fait suivant la rgle suivante :
si a est plus fort que b alors
convertir en a
sinon
convertir en b
6.2. Affectation
Laffectation permet de modifier les expressions qui se situent gauche de
loprateur, deux types daffectation :
Laffectation simple, seffectue laide de loprateur =
Laffectation compose, seffectue laide dun oprateur op= construit

partir de loprateur = et lun des oprateurs (+, -, *, /, %).
Syntaxe
expr1 = expr2 /* Affectation simple */
expr1 op= expr2 /* Affectation compose */

Laffectation compose, expr1 op= expr2 est quivalente expr1

= expr1 op expr2.
A.Zahi/DI/FSTF
46
Exemple
#include <stdio.h>
void main()
{
int a, b ;
scanf(%d %d, &a, &b) ;
/* reste de la division de a par b*/
a %= b ;
a += b ;
a /= b ;
printf(le reste est %d, a) ;
}
6.3. Incrmentation dcrmentation

Ce sont des oprateurs unaires qui permettent respectivement dajouter et de
retrancher 1 la valeur de leur oprande.
Syntaxe
++ expr, expr++
--expr, expr--
/* Incrmentation */
/* Dcrmentation */
Loprateur ++ permet dajouter 1 la valeur de son oprande, les

expressions ++x et x++ sont quivalentes x=x+1
Loprateur -- permet de retrancher 1 la valeur de son oprande,

les expressions --x et x-- sont quivalentes x=x-1
La modification de lexpression se fait avant ou aprs lvaluation

de lexpression et ceci suivant que loprateur est plac avant ou
aprs lexpression :
expr, ++ expr : la modification se fait avant lvaluation
expr--, expr ++: la modification se fait aprs lvaluation.
Exemple
#include<stdio.h>
main()
{
int a=50, b=60, x,
printf("a =%d ** b
x = ++a;
y = --b;
printf("\nx =%d **
x = a++;
y = b--;
printf("\nx =%d **
y;
= %d", a, b);
y = %d", x, y);
y = %d", x, y);
}
A.Zahi/DI/FSTF
47
6.4. Oprateurs Logique

Le rsultat dune opration logique est de type boolen. Or le type boolen
nexiste pas en C, la valeur dune expression est 1 si elle est vraie, 0 si elle est
fausse. Toute valeur non nulle est considre comme vraie et une valeur nulle
comme fausse.
Syntaxe
expr1 op expr2

expr1, expr2 constituent les oprandes.
op est lun des oprateurs suivants : et logique (&&), ou logique (||),

ngation (!), galit(==), diffrent (!=), suprieure (>), suprieure ou
gale(>=), infrieure(<), infrieure ou gale(<=),
Exemple
char c ;
int i, age, n
float m ;
(c != .)
(i <= n && exist ==1)
(m>=12 && age <=24) || (m>=12 && age <26)
6.5. Oprateur conditionnel

Loprateur conditionnel ?: est un oprateur ternaire, ses oprandes sont
des expressions.
Syntaxe
expr1 ? expr2 : expr3

La valeur de lexpression conditionnelle est lune des expressions

expr2 ou expr3. Si lexpression expr1 est vraie alors le rsultat est
la valeur de lexpression expr2 sinon i.e., expr1 est fausse le
rsultat est la valeur de lexpression expr3.
Exemples
1. Le programme ci-dessous permet dafficher la valeur absolue dun entier en
utilisant loprateur conditionnel.
#include <stdio.h>
main()
{
int x , abs_x;
printf (donner x : ) ;
scanf(%d , &x) ;
abs_x = (x>=0) ? (x) : (-x) ;
printf (valeur absolue de x est : %d , abs_x) ;
}
A.Zahi/DI/FSTF
48
2. Le programme ci-dessous permet dafficher le maximum de deux entiers.

#include <stdio.h>
void main()
{
int x ,y, max;
printf (donner x et y : ) ;
scanf(%d%d , &x, &y) ;
max = (x>y) ? (x) : (y) ;
printf (le maximum de x et y est : %d ,
max) ;
}
6.6. Expression
Une expression permet de reprsenter une valeur dans un programme. On
distingue deux types dexpressions :
Expression simple, constitue par une seule variable, une seule constante
(littrale ou symbolique).
Expression complexe, forme par une suite, doprateurs et

doprandes, les oprandes peuvent tre des variables, des constantes
(littrales ou symboliques) ou des appels de fonctions.
Exemple
#define PI 3.14
#define G 9.8
#define TVA 0.20
int prixHT ;
/* Expressions simples*/
PI, G, /*constantes symboliques */
50, -1.6, /*a constantes littrales */
prixHT /* variable */
/* Expressions complexes */
2+8,
prixHT * TVA
7. Structures de contrle
7.1. Le choix
7.1.1. if sans else
Syntaxe
if(expr)
Partie_alors

Partie_alors : un bloc dinstructions
Si la valeur de expr, lexpression entre parenthses, est non nulle ce

bloc est excute, sinon on fait rien.
A.Zahi/DI/FSTF
49
Exemples
1. Calcul de la valeur absolue d'un nombre rel.
#include <stdio.h>
main()
{
float X, Val_X ;
printf("saisir la valeur de X :");
scanf("%f", &X) ;
Val_X = -X ;
if (X > 0)
Val_X = X ;
printf("valeur absolue de %f = %f", X, Val-X) ;
}
2. Calcul du maximum de deux entiers

#include <stdio.h>
main()
{
int x, y, Max ;
printf("saisir la valeur de x et y :") ;
scanf("%d%d", &x, &y) ;
Max = x ;
if (x < y)
Max = y ;
print("Max(%d,%d)= ", x,y,Max) ;
}
7.1.2.
if avec else
Syntaxe
if(expr)
Partie_alors
else
partie_sinon

Partiealors et Partie-sinon sont des blocs dinstructions.
La partiealors est excute si la valeur de expr, lexpression entre

parenthses, est non nulle. Sinon, cest la partie-sinon qui est
excute.
Remarque
Lexpression expr doit tre toujours entre parenthses.
A.Zahi/DI/FSTF
50
Exemples
1. Le programme suivant saisit deux entiers, x et y , et dcide si x est
divisible par y .
#include <stdio.h>
main()
{
int x, y;
printf("Saisir x et y : ") ;
scanf("%d%d", &x,&y);
if (x % y == 0 )
print("%d est divisible par %d",x,y);
else
printf("%d nest pas divisible par %d",x,y);
}
2. Une droite est dfinie par deux points, A = (x1 , y1 ) et B = (x 2 , y 2 ) ,

lalgorithme ci-dessous saisit les points, A , B et P = (x , y ) , et dcide si le
point P appartient la droite ( AB ) .
#include <stdio.h>
main()
{
float x, y, xa, ya, xb, yb;
printf("Saisir le point A : ") ;
scanf("%f%f", &xa, &ya);
printf("Saisir le point B : ") ;
scanf("%f%f", &xb, &yb);
printf("Saisir le point P : ") ;
scanf("%f%f", &x, &y);
if ((ya-y)*(xb-x) = (xa-x)*(yb-y) )
printf("P appartient la droite") ;
else
printf("P nappartient pas la droite") ;
finsi
}
7.1.3.
Imbrication des tests
Lorsquon a des tests imbriqus une ambigut se pose concernant

linstruction if dont dpend une partie else. Deux cas se prsentent :
1er Cas : Par dfaut, un else est associ au if le plus proche. Dans
lexemple suivant le else est associ if(expr2).
if (expr1)
if(expr2)
inst1
else
inst2
A.Zahi/DI/FSTF
51
Exemple
Maximum de trois entiers
#include <stdio.h>
main()
{
int a,b,c,max ;
printf (" Saisir a, b et c :") ;
scanf("%d%d", &a,&b) ;
if a > b)
if (a > c)
max
else
max
else
if (b > c)
max
else
max
= a ;
= c ;
= b
= c
printf("Max = %d", Max) ;

}
2me Cas : Un else doit tre associ un if plus loin. Lambigut est leve
en regroupant les instructions, entre les if et else concerns, dans un bloc
dinstructions, i.e., entre accolades. Dans lexemple suivant le else est
associ if (expr1).
if (expr1)
{
if(expr2)
inst1
}
else
inst2
Exemple
Le programme ci-dessous permet de calculer la valeur de la fonction
dfinie par :
1
si x > b
f (x ) = 0
si x < a
x a
si a < x < b
b a
en un point x , saisi au clavier, les valeurs de a et b sont aussi saisis.
A.Zahi/DI/FSTF
52
#include <stdio.h>
main()
{
float x, fx, a, b;
printf (" Saisir a, b et x :") ;
scanf("%f%f%f", &a,&b,&x) ;
fx = 1;
if (x > a)
{
if (x > b)
fx = (x-a)/(b-a);
}
else
fx = 0;
printf(" f(%f)= %f",x,fx);
}
Exercices
Voir chapitre 0
7.1.4.
Switch
Linstruction switch est une instruction if gnralise qui permet, suivant la

valeur dune expression, de se brancher une tiquette de cas.
Syntaxe
switch(expr)
{
case etiq1 :
Bloc_1
case etiq2 :
Bloc_2
...
case etiqn :
Bloc_n
delfaut :
Bloc_d
etiq1, etiq2,... etiqn les tiquettes de cas.
expr est lexpression selon laquelle on effectue le choix.
Aprs lvaluation de expr, le rsultat est compar avec les tiquettes

etiq1, etiq2,..., etiqn. Si la valeur de expr concide avec lune des
tiquettes, le bloc associ est excut. Sinon cest la clause default qui est
excute.
A.Zahi/DI/FSTF
53
Il faut noter que chaque cas se termine par linstruction dchappement

break qui permet de quitter linstruction switch.
Exemple : Calculatrice des entiers

#include <stdio.h>
void main()
{
int a, b, s ;
char c;
printf(donner a, b) ;
scanf(%d%d, &a,&b) ;
scanf(%c ) ;
switch( c ) ;
{
case + :
s= a+b ;
break ;
case - :
s= a-b ;
break ;
case * :
s= a*b ;
break ;
case / :
s= a/b ;
break ;
default :
printf(ce
oprateur) ;
break ;
}
nest
pas
un
Exercices
Voir chapitre 0
7.2. Boucles
7.2.1. Boucle while
Syntaxe
while (expr)
corps-de-boucle

La partie corps-de-boucle peut tre une instruction lmentaire ou

un bloc dinstructions.
A.Zahi/DI/FSTF
54
Exemples
n
i
i =1
#include <stdio.h>
main()
{
int i, n, S ;
printf(" Saisir n: ");
scanf("%d",&n);
S=0 ;
i=0 ;
while ( i<=n)
{
S += i;
i++;
}
printf("S=%d", S);
}
2. Un client achte plusieurs produits o chaque produit est caractris par la

#include <stdio.h>
main()
{
char Rep;
float MT =0 ; mp, pu ;
Rep = 'O';
while ( Rep == 'O')
{
printf("saisir qa et pu") ;
scanf("%f%f", &qa,&pu) ;
Mp = qa*pu ;
MT = MT+mp ;
printf(" Un autre produit O/N") ;
scanf("%c", &Rep) ;
}
}
3. Saisir une phrase caractre par caractre. La fin de la phrase est identifie par
le caractre .
#include <stdio.h>
main()
{
char c;
printf("Saisir un carcatre : ") ;
c=getc() ;
while(c != .)
c=getc() ;
}
A.Zahi/DI/FSTF
55
7.2.2.
Boucle do while
Syntaxe
do
corps_de_boucle
while (expr) ;

Exemples
n
i
i =1
#include <stdio.h>
main()
{
int i, n, S ;
scanf("%d",&n);
S=0 ;
i=0 ;
do
{
S += i;
i++;
}
while (i<=n);
printf("S=%d", S);
}
2. Un client achte plusieurs produits o chaque produit est caractris par la

#include <stdio.h>
main()
{
char Rep;
float MT =0 ; mp, pu ;
Rep = 'O';
do
{
printf("saisir qa et pu") ;
scanf("%f%f", &qa,&pu) ;
Mp = qa*pu ;
MT = MT+mp ;
printf(" Un autre produit O/N") ;
scanf("%c", &Rep) ;
}
while ( Rep == 'O') ;
}
A.Zahi/DI/FSTF
56
3. Saisir une phrase caractre par caractre. La fin de la phrase est identifie par
le caractre .
#include <stdio.h>
main()
{
char c;
printf("Saisir un carcatre : ") ;
do
c=getc(stdin) ;
while(c != .);
}
7.2.3.
Boucle for
Syntaxe
for (expr1 ; expr2 ; expr3)
corps-de-boucle


Les expressions expr1 , expr2 et expr3 jouent respectivement les

rles dinitialisation, de condition darrt et dincrmentation/
dcrmentation.
Exemples
n
i
i =1
#include <stdio.h>
main()
{
int i, n, S ;
scanf("%d",&n);
S=0 ;
for (i=1; i<=n; i++)
S += i;
printf("S=%d", S);
}
A.Zahi/DI/FSTF
57
2. Calcul du maximum et du minimum dans une suite dentiers qui se termine

par un entier ngatif. La suite est saisie au clavier.
#include <stdio.h>
main()
{
int max, min, n;
printf(" Saisir n") ;
scanf("%d", &n);
for (max = min = n; n>0; )
{
if ( n < min)
min=n;
else
if (n>max)
max=n;
printf(" Saisir n") ;
scanf("%d", &n);
}
printf("Max= %d *** Min = %d", max, min) ;
}
3. Contrle de plusieurs compteurs dans une boucle for

#include <stdio.h>
main()
{
int m, n;
for (m = 1, n = 8; n < m; m++, n--)
printf("m= %d *** n= %d ", m, n);
}
4. Quotient et reste de la division entire, sans utiliser les oprateurs / et %.

#include <stdio.h>
void main()
{
int n, m, q, r;
printf(" Saisir n : ");
scanf("%d", &n);
printf(" Saisir m : ");
scanf("%d", &m);
for (q =0, r=n; r>d; q++)
r -= m;
}
printf("Quotient = %d *** Reste = %d", q,r);
A.Zahi/DI/FSTF
58
7.3. Instructions dchappement

Une instruction dchappement permet de rompre lexcution
boucle, dune fonction ou dun programme.
dune
7.3.1. Instruction break

Linstruction break permet darrter lexcution de linstruction switch et
des boucles while, for ou do-while le schma ci-dessous montre le
fonctionnement de linstruction break.
main()
{
...
...
while ( )
{
...
...
break ;
...
...
}
...
}
Exemple
#include <stdio.h>
/* la boucle sarrte la lecture du premier 5 */
void main()
{
int a ;
for (int i=0 ; i<=10; i++)
{
scanf(%d, &a);
if(a==5)
break ;
}
if (i <10)
printf (Sorite prmature)
}
7.3.2.
Instruction continue
Linstruction continue permet darrter litration en cours dans une

boucle, et lexcution recommence en dbut de boucle. Le schma ci-dessous
montre le fonctionnement de linstruction continue.
A.Zahi/DI/FSTF
59
main()
{
...
...
while ( )
{
...
...
continue;
...
}
Exemple
#include <stdio.h>
void main()
{
int n ;
float S ;
S=0;
for (int i=0 ; i<=100; i++)
{
scanf("%d", &n);
if(n==0)
continue ;
else
S=S+1/n ;
}
}
7.3.3.
Instruction return
Linstruction return permet de quitter une fonction. Quand linstruction

est rencontre lexcution de la fonction est arrte, si return est suivie dune
expression, la valeur de lexpression est transmise la fonction appelante, sinon
la valeur retourne est indtermine.
Exemple
#include <stdio.h>
float val_abs (float x)
{
if (x >=0) return x;
else
return -x;
}
int main()
{
float y ,v ;
scanf(%f, &y);
v=val_abs(y);
printf(%f, v);
return;
}
A.Zahi/DI/FSTF
60
7.3.4.
Instruction exit
Linstruction exit permet dinterrompre lexcution dun programme. Cette

fonction possde un argument de type entier qui permet dindiquer le code de
terminaison du programme.
Exemple
#include <stdio.h>
main()
{
int n ;
int c ;
scanf(%d, &n);
c=n*n;
printf(%d, c);
exit(1);
}
8. Les Pointeurs
8.1. Mmoire de lordinateur
La mmoire dun ordinateur est constitue de plusieurs cases mmoires
ranges de faon squentielle et dont la taille dpend des performances de la
machine. Chaque case est identifie par une adresse unique comprise entre 0 et
une valeur maximale qui dtermine la capacit de la mmoire installe dan la
machine. Lors du fonctionnement de lordinateur une partie de la mmoire est
occupe par le systme dexploitation (DOS, Windows 95/98/2000/NT, Unix,
etc.), le reste est utilis par les applications pour stocker les variables et les
instructions et effectuer les appels de fonctions. Quatre zones mmoires sont
rserves pour chaque programme :
La zone de code : contient les instructions des fonctions.
La zone de donnes : contient les variables globales et les variables de la

fonction main(). Lorsquun programme dclare une variable le
compilateur lui rserve automatiquement un emplacement mmoire dans
cette zone et associe une adresse son nom. Lallocation et linitialisation
des variables se font avant le lancement de la fonction main().
La pile : utilise lors de lappel des fonctions, les variables locales et les
paramtres de la fonction appele sont logs dans cette zone. La mmoire
locale est alloue au moment de lappel et libre la fin de lexcution.
Le tas (Heap) cette zone, appele aussi mmoire dynamique, contient
les donnes dont la taille augmente ou diminue au cours de lexcution
dun programme.
A.Zahi/DI/FSTF
61
Mmoire centrale
Applications:traitement
de texte Word, Tex...),
Tableurs (Excell,...)
Dessins(
Paint,...)
Compilateurs (C, C++,
Autocad,
Segment de donnes
Segment de code
Segment de Pile
visual Basic...)
Programmes Utilisateurs
Segment heap
Systmes
dexploitation
Linux, DOS, Windows...
8.2. Notion de pointeur

Un pointeur est une variable numrique qui contient ladresse dun
emplacement mmoire, on dit que le pointeur pointe sur un emplacement
mmoire. Cest une association indirecte avec le contenu de lespace point.
Valeur de X
Adresse de X
Variable X
Pointeur vers X
Deux pointeurs utiles :
Pointeur NULL : permet de reprsenter un pointeur invalide i.e., un

pointeur qui ne pointe sur aucun espace mmoire. La valeur NULL est
dclare dans le fichier en-tte <stddef.h> .
Pointeur gnrique void* : permet de pointer sur nimporte quel type

dobjet. Il est surtout utilis dans les fonctions qui retournent un pointeur
sur un objet dont lespace est allou dynamiquement.
A.Zahi/DI/FSTF
62
8.3. Dclaration
Syntaxe
nom_Type
*nom_pointeur
Nom_Type , reprsente le type de base de la variable pointe.
Nom_pointeur, est le nom de la variable pointeur. Le choix du nom

suit les mmes rgles que pour le choix dune variable simple.
Loprateur * indique que nom_pointeur est de type pointeur.
Exemple
void main()
{
int *ptr_entier ; /* pointeur sur un entier*/
long int *ptr_long; /*pointeur sur un entier long*/
double *ptr_double; /* pointeur sur un rel double*/
char *ptr_carac ; /* pointeur sur un caractre*/
}
Remarque
La dclaration dune variable de type pointeur consiste lui rserver un
espace en mmoire dans le segment heap (mmoire dynamique) .
8.4. Initialisation
Comme pour les variables simples, un pointeur non initialis peut provoquer
des problmes dexcution. En effet, quand on dclare un pointeur, ce dernier est
initialis par une valeur quelconque (i.e., une adresse quelconque). Pour cela, un
pointeur doit tre initialis avant toute utilisation, cest le programmeur qui
doit sen charger. Il existe deux faons dinitialiser un pointeur : par une adresse
existante, en utilisant loprateur dadressage, ou en lui attribuant une nouvelle
adresse.
8.4.1.
initialisation laide de loprateur dadressage &
Un pointeur peut tre initialis par ladresse dune variable qui existe dj.
Linitialisation a la forme suivante :
Syntaxe
type X ;
type* ptr_X ;
ptr_X= &X ; /* affectation de ladresse de X ptr_X */

Loprateur & renvoie ladresse de la variable en paramtre.
A.Zahi/DI/FSTF
63
Exemple
void main()
{
int
X = 25; /* X contient la valeur 25
*/
int *ptr_X ;
ptr_X = &X ; /* ptr_X contient ladresse de X */
}
8.4.2.
Initialisation laide de la fonction malloc ()
Un pointeur peut tre initialis par ladresse dune case mmoire rserve au
cours de lexcution du programme. Pour ce faire nous avons besoin des
fonctions malloc() et sizeof() qui sont situes dans la bibliothque <stdlib.h> ou
dans <alloc.h>.
Syntaxe
/* initialisation dun pointeur*/
nom_type *ptr_X ;
int t= sizeof(nom_type) ;
ptr_X= (nom_type* ) malloc(t) ;

sizeof est un oprateur qui retourner la taille dun type i.e., la taille
de lespace mmoire ncessaire pour loger une variable de ce type.
malloc est une fonction qui permet de rserver un espace mmoire de

taille t et de retourner son adresse.
Linitialisation dun pointeur dans ce cas consiste, convertir

ladresse retourne par la fonction malloc au type dsir ensuite
laffecter ptr_X.
Exemple
int *ptr_X ;
/* allocation mmoire pour une variable entire X */
ptr_X = (int *) malloc (siezof(int)) ;
double *ptr_d ;
/* allocation mmoire pour une variable relle */
ptr_d = (double* ) malloc (siezof(double)) ;
8.5. Indirection
Aprs la dclaration et linitialisation dun pointeur, nous avons besoin de
manipuler la variable pointe. Pour accder cette variable on utilise loprateur
* suivant la syntaxe suivante :
A.Zahi/DI/FSTF
64
Syntaxe
nomtype X ;
nomtype *ptr_X ;
ptr_X =( nomtype *) malloc(sizeof(nomtype)) ;
X=*ptr_X ;

Loprateur * dlivre la valeur pointe par ptr_X .
*ptr_X reprsente une variable de type nomtype sur laquelle on

peut effectuer toutes les oprations permises sur le type nomtype,
Lecture, affichage, oprateurs, etc.
Exemple 1
#include<stdio.h>
void main( )
{
int i = 0;
int *p;
float x = 3.14;
float *f;
f= (float* ) malloc(sizeof(float));
scanf(%f, f);
p = &i;
*f = 666;
f = &x;
printf(%f,*f);
*f = *p;
*p = 34;
*p = *p + 1;
printf( "%d %f %d\n", i, *f, *p );
}
Remarques
Si ptr_X est un pointeur sur une variable X, alors *ptr_X et

contiennent le mme contenu.
Linitilisation dun pointeur au moment de la dclaration permet

dinitialiser la valeur du pointeur et non le contenu de lespace point.
int* p = &x ; /* Juste*/
int* p = 10 ; * Faux*/
8.6. Libration de lespace

La fonction free permet de librer un espace mmoire qui a t allou par
la fonction malloc, cette fonction est appele une fois quon a plus besoin de cet
espace.
Syntaxe
free(p);
A.Zahi/DI/FSTF
65
9. Les fonctions
9.1. Analyse descendante
En utilisant les lments de programmation prsents prcdemment
(oprateurs, instructions de choix, boucles, etc.), il est facile de rsoudre tous les
problmes relativement simples. Cependant pour les problmes complexes et de
grandes tailles, il faudrait utiliser une mthodologie pour construire la solution
correspondante. Lanalyse descendante est lune des mthodes les plus utilise
pour le dveloppement dune solution informatique pour les problmes
complexes. Lanalyse descendante est base sur la technique diviser pour
rgner qui consiste :
Dcomposer le problme en sous problmes indpendants, dcomposer

eux-mmes en sous problmes et ainsi de suite jusqu ce quon arrive
des problmes triviaux.
Rsoudre les sous problmes triviaux sparment, pour chaque sous

problme on conoit un sous programme quon appelle fonction.
Combiner les sous programmes (fonctions) obtenus pour construire la

solution globale du problme.
P
P1
P11
P2
P12
P3
P31
P32
P33
P321
P322
Figure 11 : Dcomposition dun problme
Une fonction, est un ensemble dinstructions ralisant une tche bien prcise,
elle peut tre considre comme une bote noire qui reoit en entre des donnes
et fournit des rsultas en sortie.
Donnes
Fonction
Figure 12 : Schma dune fonction
A.Zahi/DI/FSTF
Rsultats
66
Exemple : Calcul de f n (x ) =
1 i =n i
x
n! i =1
Ce problme peut tre dcompos en trois sous problmes :

P1 : calculer n! , pour n donn.
P2 : calculer x n , pour n et x donns.
P3 : calculer la somme.des puissances croissantes de x
Fact(n), Puiss(x,n) et Som(x,n) sont les fonctions (sous

programmes) qui permettent de rsoudre respectivement les sous
problmes P1, P2 et P3.
La solution globale du problme se prsente comme suit :

(1/Fact(n))*Som(x,n)
La fonction Puiss est utilise dans la foncfion Som(x,n).

9.2. Pseudo-fonction
Une pseudo-fonction, appele macro avec paramtres, permet de reprsenter
une expression simple, elle est dfinie par la directive #define
Syntaxe
#define IDENF (paramtres) (expression)

IDENF Identificateur qui reprsente le nom de la macro.
expression: chane de caractres qui reprsente lexpression de la macro,

lorsque le prprocesseur rencontre la chane IDENF, il remplace le texte
de la macro par expression.
Dans lexpression chaque paramtre doit tre entre parenthses.
Exemple
#include <stdio.h>
#define CARRE(x) ((x)*(x))
#define MAX(x,y) ((x) >(y) ? (x):(y))
void main()
{
int n,m, M, C ;
printf("donner n et m: ");
scanf("%d%d", &n, &m);
M = MAX(m,n) ;
printf("Le max est : %d", M);
C = CARRE(n)
printf(" le carr de %d est : %d", n, C) ;
}
A.Zahi/DI/FSTF
67
Remarque
Les parenthses entourant les arguments sont ncessaires pour viter les
effets de bord, En effet si on dfinie la macro : #define carre (x) x*x,
linstruction r=carre (x+y) ; sera remplace par lexpression x+y*x+y ;
9.3. Dclaration des fonctions utilisateur
La dclaration dune fonction en C est constitue par deux parties :
La partie interface, appele aussi prototype, spcifie lapparence de la

fonction : le nom, les donnes et les rsultats fournies par la fonction.
La partie corps spcifie le comportement de la fonction i.e., les

instructions excuter sur les donnes pour obtenir les rsultats.
9.3.1.
Prototype dune fonction
Linterface est constitue par trois lments chacun joue un rle particulier.
Syntaxe
type_retour nom_fonction(liste des paramtres)

type_retour indique le type de la valeur que la fonction doit retourner.

Ce type peut tre lun des types simples ( int, float, double, char,...).
Dans le cas o la fonction ne retourne aucune valeur on doit spcifier
void comme type de retour.
nom_fonction indique le nom de la fonction, celui-ci doit suivre les

mmes rgles que les noms des variables simples. Il est prfrable de
choisir, pour les fonctions, des noms qui indiquent ce quelles font.
Liste des paramtres, appele aussi paramtres formels, ce sont les

objets (donnes et rsultats) sur lesquelles sexcute la fonction. Pour
chacun des paramtres on doit prciser le type, lidentificateur et la
nature : fixe ou variable.
Un paramtres fixe est un objet sur lequel il ny a aucun effet

par la fonction, la valeur en entre est la mme quen sortie. Ce
type concerne les donnes de la fonction. On le dclare de la
manire suivante :
type_retour nom_fonction(type1 id, ..., ...)
Un paramtre variable est un objet qui peut tre modifi par la

fonction, la valeur en entre nest pas toujours la mme que
celle de en sortie. Ce type de paramtre concerne les rsultats de
la fonction. On le dclare de la manire suivante :
type_retour nom_fonction(type1 *id,..,...)
A.Zahi/DI/FSTF
68
Exemples
/*a et b : paramtres fixes. */
int somme (int a, int b) ;
/*a et b : paramtres fixes, s : paramtre variable*/.
void somme(int a, int b, int *s) ;
/*fonction sans paramtres */
void affiche () ;
/*a et b : paramtres variables.*/
void echange (int *a, int* b) ;
9.3.2.
Corps de la fonction
Le corps de la fonction est plac entre accolades la suite de len-tte.

Syntaxe
{
}

dclarations des variables locales

instructions
return expression ;
Variables locales ce sont des variables dclares dans la fonction et

qui ne sont pas visibles lextrieure.
Instructions reprsentent les oprations qui permettent deffectuer la

tche de la fonction. Quand la fonction est appele, lexcution
commence la premire instruction qui suit laccolade ouvrante et se
termine la rencontre de la premire instruction return ou de
laccolade fermante.
return permet de renvoyer la valeur dune expression la fonction

appelante. Lorsque cette instruction est rencontre lexpression est
value et la valeur trouve est transmise la fonction appelante.
Exemples
1. fonction main
void main ()
{
printf(bonjour Bonjour) ;
}
2. Maximum de deux entiers : sans type de retour

void Maximum (int a, int b, int* Max)
{
*Max = a ;
if (a>=b)
*Max = b ;
}
A.Zahi/DI/FSTF
69
3. Somme de deux entiers : avec type de retour, avec paramtre

int somme(int a, int b)
{
int s ; /* variable locale */
s= a+b ;
return s ;
}
4. Valeur absolue
float Val_Abs(float a)
{
float abs ;
if (a>=0)
abs = a ;
else
abs = -a
return abs ;
}
9.3.3.
Comment obtenir une fonction
Pour lcriture dune fonction on doit rpondre aux questions suivantes :
Quel la valeur que la fonction doit retourner ? Cette valeur dfinie le

type de retour de la fonction.
Quels sont les donnes dont la fonction a besoin pour effectuer sa tche ?
Les donnes constitueront les paramtres fixes de la fonction.
Quels sont les rsultats que la fonction doit fournir ?. Les rsultats
constitueront les paramtres variables de la fonction.
Quelles sont les instructions qui permettent dobtenir les rsultats partir
des donnes ? Les instructions constitueront le corps de la fonction.
9.4. Appel dune fonction

9.4.1. Principe
Une fois dclare, une fonction peut tre utilise dans plusieurs parties du
programme, on parle ainsi de lappel de fonction. Au moment de lappel, la
fonction appelante transmet la fonction appele les paramtres effectifs
(valeurs des paramtres formels); ensuite le corps de la fonction appele est
excute, aprs, la fonction appelante reprend lexcution la ligne qui suit la
ligne dappel et rcupre ventuellement un rsultat.
A.Zahi/DI/FSTF
70
Fonction
appelante
Fonction
appele
Paramtres
effectifs
Suspension de
lexcution
Excution de
la fonction
Valeur de
retour
Reprise de
lexcution
Retour vers
lappelant
Figure 13 : Processus de lappel dune fonction
9.4.2.
Syntaxe de lappel
Lappel dune fonction constitue un paramtre dans une instruction :
Affectation une variable :

variable = nom_fonction (paramtres effectifs)
Paramtre effectif dune autre fonction

fonc(nom_fonction (paramtres effectifs))
Un facteur dans une expression :

Var1 = nom_fonction (paramtres effectifs)* var2
Exemples
1.
Valeur absolue
#include <stdio.h>
float absolue( float a)
{
float abs ;
abs = a ;
if( a <0)
abs =-a
return abs ;
}
void main()
{
float x, y, Max ;
printf(" Entrer la valeur de x : ") ;
scanf("%f ", &x) ;
/* appel de la fonction absolue*/
printf("%f", absolue(x)) ;
}
A.Zahi/DI/FSTF
71
2.
Maximum de deux entiers

#include <stdio.h>
Maximum ( int a,int b ,int * max )
{
*Max=a ;
if (a>=b)
*Max = b
}
void main()
{
float x, y, max ;
printf(" Entrer la valeur de x : ") ;
scanf(" %d", &x) ;
printf(" Entrer la valeur de y : ")
scanf(" %d", &y) ;
/* appel de la fonction max */
Maximum(x,y, &max)
printf (" %d", max)
}
Remarques
Diffrence entre paramtres formels et paramtres effectifs :
Les paramtres formels sont spcifis lors de la dclaration de la

fonction
9.4.3.
Les paramtres effectifs sont spcifis au moment de lappel.
Lors de lappel dune fonction on doit respecter les contraintes suivantes :
Le nombre de paramtres effectifs doit tre le mme que celui des

paramtres formels.
Lordre des paramtres effectifs doit tre le mme que celui des
paramtres formels.
Les paramtres effectifs et les paramtres formels doivent tre de

mme type.
Passage des paramtres
Lors de lappel dune fonction, la fonction appelante transmet les paramtres

la fonction appele, deux modes de transmission sont possibles :
Passage par valeur : la fonction appelante ne transmet quune copie du

paramtre effectif, par suite la fonction na aucun effet sur le paramtre en
question. Ce sont les paramtres fixes qui sont concerns par ce mode de
transmission.
Passage par adresse: la fonction appelante transmet lemplacement

mmoire du paramtre effectif, par suite la fonction peut avoir un effet sur
le paramtre en question. Ce sont les paramtres variables qui sont
concerns par ce mode de transmission.
A.Zahi/DI/FSTF
72
En langage C la mthode utilise pour le passage des paramtres est le

passage par valeur. Le passage par adresse est ralis explicitement par le
programmeur en passant ladresse du paramtre au lieu de sa valeur. Le passage
des paramtres se ralise selon les tapes suivantes:
Copier les valeurs des paramtres dans la pile.
Allouer lespace mmoire, dans la pile, pour les paramtres et les

variables locales de la fonction appele.
Excuter le corps de la fonction et stocker les rsultats de la fonction dans

la pile.
Rcuprer les valeurs sur la pile
Exemple1 : Excution dune fonction avec un paramtre fixe.

int x=20, y ;
y = f2(x) ;
Mmoire
centrale
int f2(int x)
{
x= x+x ;
return x ;
}
x = 20
y=40
1. Copier x
sur la pile
2. Excuter
la fonction
4.
3. Stocker le rsultat
sur la pile
Rcuprer le rsultat
de la pile
x = 20
x= 40
Pile
Figure 14 : Passage par valeur
A.Zahi/DI/FSTF
73
Exemple 2 : Excution dune fonction avec un paramtre variable.

int x=20, y ;
f2(&x) ;
Mmoire
centrale
void f2(int * x)
{
*x= *x + *x ;
}
x = 20
x = 40
1. Copier &x
sur la pile
2. Excuter
la fonction
3. lire la valeur du
paramtre partir de
la M. C. (&x)
&x
4. Stocker
le rsultat
dans la M.C. &x
Pile
Figure 15 : Passage par adresse
9.4.4.
Port des variables
On distingue deux catgories de variables :
Variables locales : ce sont des variables dclars lintrieur dune

fonction. Ces variables ne sont pas accessibles partir des autres
fonctions.
Variables globales : ce sont des variables qui ne sont dclares dans

aucune fonction. Les variables dclares dans la fonction main sont aussi
des variables locales. Les variables globales sont visibles partout dans le
programme i.e., dans toutes les fonctions.
A.Zahi/DI/FSTF
74
Exemple
#include <stdio.h>
int m;/* variable globale */
void init0()
{
m = 0;
printf("\n %d",m);
}
void init1(int t)
{
int k =15 ; /* variable local */
t = k+ 1;
printf("\n %d",t);
}
void init2(int *p)
{
*p = 2;
printf("\n %d",*p);
}
void main()
{
int n; /* variable locale*/
init0();
printf("\n %d",m);
n = m;
init1(n);
printf("\n %d",n);
init2(&n);
printf("\n %d",n);
init2(&m);
printf("\n %d",m);
init1(m);
printf("\n %d",m);
}
le rsultat de ce programme est : 0 0 16 0 2 2 2 2 16 2

Exercices
1. Ecrire une fonction qui retourne limage dun rel par la fonction dfinie
par le graphe suivant :
1
A.Zahi/DI/FSTF
75
2.
Ecrire un programme qui calcul la valeur
i =n
xi
i! ,
Ecrire les fonctions
i =1
ncessaires.
3.
Ecrire un programme qui saisit un entier p et dtermine sil est parfait,

premier, triangulaire ou premier avec un entier saisi. Le programme doit
permettre lutilisateur de choisir lopration dsire.
A.Zahi/DI/FSTF
76
Chapitre 2: Tableaux et Chanes de

caractres
1. Tableaux uni dimensionnels

Un tableau uni dimensionnel est une structure qui abrite un ensemble fini
dlments de mme type. Un tableau occupe une place contigu dans la
mmoire i.e., les lments sont stocks les un la suite des autres.
21
1er lment
12
2 me lment
3
Tableau
.
.
.
20
dernier lment
Figure 16 : Stockage dun tableau en mmoire
1.1. Dclaration
Syntaxe
type_element nom_tableau[CAP];

nom_tableau est un identificateur qui indique le nom de la variable,
type_element indique le type des lments du tableau,
CAP est une constante qui indique le nombre maximal dlments

quon peut stocker dans ce tableau.
A.Zahi/DI/FSTF
77
Remarque
Il est recommand de dfinir la constante qui indique la capacit du

tableau comme une constante symbolique :
#define CAP 10
int t[CAP];
Les tableaux en C sont indexs de 0 CAP-1.
La taille dun tableau doit tre connue au moment de la dclaration, on ne

peut donc pas faire les dclarations suivantes:
int t[ ];
int t[n]; avec n.une variable.
Il est impratif de dclarer un tableau avec une capacit maximale CAP,

cependant il nest pas obligatoire dutiliser tous les CAP lments. Pour
indiquer la taille effective du tableau i.e., le nombre dlments
effectivement utiliss, on accompagne la dclaration du tableau par la
dclaration dun entier N qui joue ce rle.
Ainsi la dclaration dun tableau devient :
#define CAP 10
/* Capacit du tableau */
int N ;
int t[CAP];
/* Taille du tableau
*/
Exemples
#define CAP1 15
#define CAP2 20
#define CAP3 30
void main()
{
/* tableau qui peut contenir 15 entiers */
int t[CAP1] ;
/* tableau qui peut contenir 20 rels*/
double r[CAP2] ;
/*tableau qui peut contenir 30 caractres*/
char nom[CAP3] ;
}
1.2 Initialisation dun tableau

Il est possible dinitialiser lintgralit ou seulement une partie dun tableau,
par une liste de constantes au moment de la dclaration. Linitialisation permet
daffecter aux lments, respectivement et partir de 0, les constantes entre
accolades. Dans le cas o la taille nest pas indique le compilateur cre un
tableau avec autant dlments que de valeurs entre accolades.
A.Zahi/DI/FSTF
78
Exemple
#define CAP 5
/* initialisation de lintgralit du tableau*/
int t[CAP] = {1,2,3,4,8};
/* initialisation dune partie du tableau*/
int k[CAP] = {1,2};
/* initialisation sans indiquer la taille */
int l[] = {4,7,9,76};
1.3. Accs un lment du tableau

Chaque lment du tableau est identifi par son rang. Pour y accder on
utilise loprateur dindexation [.] avec le rang de llment comme paramtre.
Syntaxe
nom_tableau [exp] ;

exp est une expression dlivrant une valeur entire qui indique le rang de
llment dans le tableau.
Si T est un tableau, T[i] reprsente son (i+1)eme lment, Ainsi T[i] peut
tre considr comme une variable simple sur laquelle on peut effectuer
les oprations suivantes :
Saisie : scanf("%car", &T[i] ) ; o car est un spcificateur

de format de lun des types de base.
Affichage : printf("%car", T[i]

spcificateur de lun des types de base.
Affectation :
/*valeur dune constante*/
T[i]= Constante;
/*valeur dune expression*/
T[i]= expression;
/*valeur dune autre variable*/
T[i]= X ;
Elment dune expression :

S=2*PI*T[i] ;
if( T[i] >=0)
T[i]= sqrt(T[i]) ;
A.Zahi/DI/FSTF
);
o car est un
79
Exemple
Ce programme permet de saisir un tableau dentiers, de remplacer chaque
lment par la somme de ses diviseurs et dafficher le tableau rsultant.
#include <stdio.h>
#define CAP 10
void main()
{
int T[CAP], n, s, d ;
/* Saisie du tableau */
printf (entrer la taille du tableau :) ;
scanf(%d, &n) ;
for (int i=0 ;i<n ; i++)
{
printf(Donner T[%d] : ,i) ;
scanf(%d, &T[i]) ;
}
/* Recherche des diviseurs */
{
s=1 ;
d=2 ;
while (d<=T[i])
{
if(T[i]%d==0)
s += d ;
d++;
}
T[i]=s ;
}
/* Affichage du tableau */
printf (T[%d] = %d , i, T[i]) ;
}
1.4. Pointeurs et Tableaux

1.4.1. Le nom dun tableau
La dclaration type_tab T[CAP] consiste rserver lespace mmoire pour
CAP lments de type type_tab. Lors de lutilisation de lidentificateur T,
chaque occurrence de T sera convertie en une valeur constante dont :
Le type est un pointeur vers le type type_tab ,
La valeur est ladresse du premier lment du tableau.
Remarques
La conversion na lieu que pour les identificateurs des tableaux qui

apparaissent dans une expression et non lors de la dclaration.
Le nom dun tableau est un pointeur constant. i.e., On ne peut pas

modifier sa valeur au cours de lexcution du programme. Ainsi on ne
A.Zahi/DI/FSTF
80
peut rien lui affecter, no moins on peut crer un pointeur variable qui
pointe vers le premier lment.
int tab[10] ;
int * ptr_tab ;
ptr_tab=tab ;
tab= ptr_tab
1.4.2.
Incrmentation et dcrmentation
Les lments dun tableau sont stocks en mmoire les un la suite des
autres et le nom du tableau contient ladresse du premier lment. Pour accder
un lment du tableau on doit donc se positionner son adresse. Pour cela le
nom du tableau doit tre incrment ou dcrment, i.e., augmente ou diminue
par la taille du type des lments du tableau, jusqu atteindre llment cherch.
Exemple
#include <stdio.h>
#define CAP 10
void main()
{
int T[CAP], n, s, d ; *p ;
scanf(%d, &n) ;
p=T;
{
printf("Donner T[%d] : ",i) ;
scanf("%d", p]) ;
p++ ;
}
p=T;
{
s=1 ; d=2 ;
while (d<=*p)
{
if(*p % d==0)
s += d ;
d++;
}
*p=s ;
}
p=T ;
{
printf (T[%d] = %d , i, *p) ;
p++;
}
}
A.Zahi/DI/FSTF
81
1.4.3.
Indexation du tableau
Comme on a dj vu, le nom dun tableau est un pointeur vers le premier

lment. Par suite pour accder sa valeur on doit utiliser loprateur *. Ainsi, si
t est un tableau alors *t reprsente le premier lment de t et pour accder au ieme
lment du tableau on doit incrmenter le non du tableau de i i.e., utiliser
lexpression *(t+i). Ainsi lexpression t[i] est quivalente *(t+i).
Exemple
#include <stdio.h>
#define CAP 10
void main()
{
int t[CAP], n, S, d ;
scanf(%d, &n) ;
{
printf(Donner t[%d] : ,i) ;
scanf(%d, t+i) ;
}
{
s=1 ;
d=2 ;
while (d<=*(t+i))
{
if(*(t+i)%d==0)
s += d ;
d++;
}
*(t+i)=s ;
}
printf (t[%d] = %d\t , i, *(t+i)) ;
}
1.4.4.
Tableaux dynamiques
Avec la dclaration, type tab[MAX], lespace ncessaire au stockage est

allou au dbut de lexcution du programme. Pour crer un tableau dont la
taille est dtermine au moment de lexcution on doit dclarer le tableau avec
un pointeur variable.
Syntaxe
/* dclaration dun tableau dynamique */
nomtype *tab ;
/* allocation de lespace ce tableau */
tab = (nomtype*) malloc(t * sizeof(nomtype)) ;
A.Zahi/DI/FSTF
82
Lespace rserv aux tableaux dynamiques est allou au cours de

lexcution du programme en utilisant la fonction malloc.
Lallocation de lespace mmoire au tableau tab de talle t consiste

rserver t cases mmoire de taille sizeof(nomtype).
Exemple
int
*t
;
double *d
;
char
*c
;
/* allocation de lespace un tableau de 10 entiers
t = (int ) malloc(10 * sizeof(int));
/* allocation de lespace un tableau de 40 rels
d = (int ) malloc(40 * sizeof(double));
*/
*/
/* allocation de lespace un tableau de 20 caractres */

c = (char ) malloc(20 * sizeof(double));
1.5.
Tableau paramtre dune fonction
Un tableau uni-dimensionnel est dfinie par ladresse du premier lment et

la taille effectif. Ainsi, le passage dun tableau comme paramtre une fonction
consiste lui passer ces deux informations, la syntaxe est la suivante :
Syntaxe
Dclaration de la fonction
La taille nest pas modifie par la fonction
type nom_fonc1 ( type tab[CAP], int taille) ;
type nom_fonc2 ( type tab[], int taille) ;
type nom_fonc2 ( type *tab, int taille) ;
La taille est modifie par la fonction

type nom_fonc1 ( type tab[CAP], int *taille) ;
type nom_fonc2 ( type tab[], int *taille) ;
type nom_fonc2 ( type *tab, int *taille) ;
Appel de la fonction
type tab[10] ;
int n ; /* taille du tableau */
nom_fonc1(t,n) ;
nom_fonc2(t,&n) ;
Remarques
La fonction na pas besoin de la taille maximale du tableau car on ne

rserve de lespace sur la pile qu ladresse du premier lment et la
taille effective. Laccs un lment du tableau est effectu par son
adresse, calcule partir de celle du premier lment. Le dernier lment
du tableau est identifi par la taille effective.
A.Zahi/DI/FSTF
83
La fonction peut avoir un effet sur tous les lments du tableau, mais pas
sur la valeur du paramtre qui est de type pointeur i.e., ladresse du
premier lment ne change pas par la fonction. Par exemple, Aprs lappel
de la fonction :
void remplir(int *t, int n)
{
int *p = t + n ;
while ( t != p)
{
*t =*t + 2 ;
t++ ;
}
}
les lments du tableau sont modifis mais pas la valeur du pointeur t.

Exemple
#include <stdio.h>
#define CAP 10
/*********************************************************/
/*
FONCTION SAISIE
*/
/*********************************************************/
void Saisie (int t[], int n)
{
int i;
for (i=0 ;i<n ; i++)
{
printf(Donner t[%d] : ,i) ;
scanf(%d, t+i) ;
}
}
/*********************************************************/
/*
FONCTION AFFICHAGE
*/
/*********************************************************/
void Affichage (int *t, int n)
{
int i;
printf (t[%d] = %d\t , i, *(t+i)) ;
}
/*********************************************************/
/*
FONCTION DIVISEUR
*/
/*********************************************************/
void Diviseur (int t[CAP], int n)
{
int i, s, d;
{
s=1 ;
d=2 ;
while (d<=*(t+i))
{
if(*(t+i)%d==0)
s=s+d ;
d++;
}
*(t+i)=s ;
}
}
A.Zahi/DI/FSTF
84
/*********************************************************/
void main()
{
int t[CAP], n;
scanf(%d, &n) ;
Saisie(t,n) ;
Diviseur (t,n) ;
Affichage (t,n) ;
}
2. Tableaux de dimension deux

Un tableau de dimension deux est un tableau uni-dimensionnel de dimension
L dont chaque lment est un tableau uni-dimensionnel de dimension C. L et C
sont les deux dimensions du tableau bidimentionnel, elles reprsentent
respectivement le nombre de lignes et le nombre de colonnes. On peut ainsi dire
quun tableau de dimension deux est une matrice de dimension L et C.
En mmoire, un tableau de dimension deux occupe un espace contigu, les
lments sont stocks ligne par ligne.
21
1er re ligne
3
14
Tableau
2 me ligne
.25
.
12
20
dernire ligne
Figure 17 : Stockage dun tableau de dimension 2
A.Zahi/DI/FSTF
85
Exemple
Pour stocker les notes des 12 modules, dune section de la fst, on utilise un
tableau de dimension n et 12, o n est le nombre dtudiants dans la section. Une
ligne du tableau reprsente les notes dun tudiant dans les 12 modules. Une
colonne reprsente les notes de tous les tudiants dans un module.
E1
E2
.
.
.
En
M1
12
05
M2
09
14
13.5 15
.
.
.
.
.
.
.
.
.
M12
16
12
16
2.1. Dclaration
Syntaxe
type_element nom_tableau[MAX_LIN]
[MAX_COL];
nom_tableau est un identificateur qui indique le nom de la variable.
type_element indique le type des lments du tableau.
MAX_LIN et MAX_COL sont des constantes qui indiquent,

respectivement, le nombre maximal dlments quon peut stocker
dans une ligne respectivement dans une colonne.
Exemple
/* matrice dentiers de 7 lignes et 6 colonnes */
int matrice[7][6] ;
/*texte de 10 lignes, chacune est forme par 80 caractres */
char texte[10][80] ;
/*tableau qui contient les notes dune section */
#define MEX_ETUD /* nombre maximale dtudiants */
float notes [MAX_ETUD][12] ;
2.2. Initialisation
Les tableaux de dimension deux peuvent tre initialiss au moment de la
dclaration par une liste dexpressions:
Exemple
int T[4][5]={ {0, 1, 2, 3, 4},
{10, 11, 12, 13, 14},
{20, 21, 22, 23, 24},
{30,31,32,33,34}}
A.Zahi/DI/FSTF
86
2.3. Accs un lment

Chaque lment du tableau est identifi par deux indices qui indiquent sa
ligne et sa colonne, pour accder un lment on utilise loprateur dindexation
avec la ligne et la colonne comme paramtres.
Syntaxe
nom_tableau [exp1][exp2] ;

exp1, exp2 sont des expressions dlivrant des valeurs entires qui
indiquent respectivement la ligne et la colonne dans le tableau.
Si T est un tableau de dimension 2, T[i][j] dsigne llment de la

ligne i et la colonne j, il est considr comme une variable simple qui
peut tre utilise dans une expression ou sur laquelle on peut effectuer
les oprations de saisie, daffichage et daffectation .
Exemple
Ce programme permet de saisir le tableau des notes des 12 modules dune
section, de calculer la moyenne de chaque tudiant, de stocker le rsultat dans la
13me colonne et dafficher la moyenne de chaque tudiant.
#define M_LIN 100
#define M_COL 15
void main()
{
float notes[M_LIN][M_COL], moy ;
int i, j, ne, nm;
/* Saisie des notes */
printf("donner le nombre dtudiants ");
scanf("%d",&ne);
for(i= 0; i<ne; i++)
for(j=0; j<12; j++)
scanf("%d", &notes[i][j];
/* Calcul de la moyenne gnrale */
for (i=0 ; i<ne ;i++)
{
moy =0.0 ;
for j=0 ; j<12 ; j++)
moy += notes[i][j];
notes[i][13]=moy;
}
/* Affichage de la moyenne de chaque tudiant */
for(i= 0; i<ne; i++)
printf(%d, notes[i][13];
}
A.Zahi/DI/FSTF
87
Exercice
Chaque semaine la direction dun magasin dappareils lectromnagers
enregistre ses ventes, en nombre dappareils, dans un tableau de vente. A la fin
du mois les rsultats sont envoys au sige. On dsire crire un programme qui
affiche le nombre dappareils vendu par semaine.
2.4. Tableau de dimension deux paramtre dune fonction
Un tableau de dimension deux est dfini par ladresse de la premire ligne,
qui est de type tableau, le nombre effectif de lignes et le nombre effectif de
colonnes. Pour passer un tableau bidimensionnel comme paramtre une
fonction on doit lui fournier ces informations. Il faut noter que la taille maximale
dune ligne, qui nest dautre que le nombre maximal de colonnes, est ncessaire
la fonction pour pouvoir accder tous les lments du tableau. La syntaxe est
la suivante
Syntaxe
Dclaration de la fonction
type_retour fonc1(type_elem Mat[][MAX], int L, int M)
type_retour fonc2(type_elem Mat[][MAX], int *L, int *M)
int L, M ;
type_elem Mat[MAXL][MAXC] ;
fonc1(Mat, L, M)
fonc2(Mat, &L, &M)

MAX est une constante qui indique la taille maximale dune ligne.
Exemple
Ce programme permet de saisir le tableau des notes des 12 modules dune
section, de calculer la moyenne de chaque tudiant, de stocker le rsultat dans la
13me colonne, de calculer le nombre de module non valid, de stocker le rsultat
dans la 14 me colonne et dafficher la liste des admis (numro de la ligne).
#define M_LIN 100
#define M_COL 20
/**************************************************/
/*
Fonction Saisie des notes
*/
/**************************************************/
void Saisie( float notes[][M_COL], int nl, int nc)
{
for(i= 0; i<nl; i++)
for(j=0; j<nc; j++)
scanf("%d", &notes[i][j];
}
A.Zahi/DI/FSTF
88
/**************************************************/
/*
Fonction Calcul de la moyenne gnrale
*/
/**************************************************/
void Cal_Moy (float notes[][M_COL], int nl, int *nc)
{
for (i=0 ; i<nl ;i++)
{
moy =0.0 ;
for j=0 ; j< *nc ; j++)
moy += notes[i][j];
notes[i][13]=moy;
}
*nc = *nc +1 ;
}
/****************************************************/
/* Fonction Calcul du nombre de modules non valid */
/****************************************************/
void Cal_nmnv (float notes[][M_COL], int nl, int *nc)
{
int nm_nv;
for (i=0 ; i<ne ;i++)
{
nm_nv = 0 ;
for j=0 ; j<12 ; j++)
if (notes[i][j]< 7)
nm_nv += 1;
notes[i][14]=nm_nv;
}
*nc = *nc +1 ;
}
/****************************************************/
/* Fonction Affichage du tableau
*/
/****************************************************/
void affiche (float notes[][M_COL], int nl, int nc)
{
for(i= 0; i<nl; i++)
{
for (int j =0; j <nc; j++)
printf("\n %d ", notes[i][j]);
printf(" \n");
}
}
/****************************************************/
/* Fonction main
*/
/****************************************************/
void main()
{
float notes[M_LIN][M_COL], moy ;
int i, j, ne, nc;
printf("donner le nombre dtudiants ");
scanf("%d",&ne);
printf("donner le nombre de modules ");
scanf("%d",&nm);
Saisie( notes, ne, nm);
Cal_Moy(notes, ne, &nm);
Cal_nmnv(notes, ne, &nm);
Affiche(notes, ne, nm);
}
A.Zahi/DI/FSTF
89
3. Chanes de caractres
Une chane de caractres est une suite de caractres. En C, bien quil existe
une bibliothque qui permet de grer les chanes de caractres, il nexiste aucun
type qui permet de les reprsenter. Une chane de caractres est donc reprsente
par un tableau de caractres. Le tableau peut tre statique ou dynamique.
3.1. Dclaration
Pour dclarer une chane de n caractres on a besoin dun tableau de n+1
lments, le dernier lment est rserv au caractre NULL \0, qui indique la
fin de la chane.
Syntaxe
char chaine[nb_caractere] ;/* reprsentation statique */
char * chaine ; /* reprsentation dynamique */

nb_caractere cest une constante qui indique le nombre de caractres

de la chane.
chaine cest un identificateur qui reprsente le nom de la chane.
Remarque
Dans le cas dune reprsentation dynamique un espace mmoire doit tre
rserv la chane, laide de la fonction malloc, avant toute utilisation :
char * ch ;
ch = (char *) malloc(nb_caractere * sizeof(char)) ;
Exemples
char Nom[7] ;/* peut contenir un nom de 7 caractres */
char* prenom
3.2. Initialisation
Les tableaux de caractres peuvent tre initialiss au moment de la
dclaration de deux faons :
Comme pour les tableaux dautres types :

char nom[3] = {A,l,i,\0};
Par une constante littrale :

char nom[4] = "Ali";
char* adresse = "25 Rue Jupiter, Systme Solaire";
char profession[] = "Pilote davion";
Remarques
Dans le premier cas il ne faut pas oublier le caractre \0 qui indique la

fin de la chane.
Dans le deuxime cas, le caractre de fin de chane est ajout

automatiquement.
A.Zahi/DI/FSTF
90
3.3. Fonctions de manipulation

La bibliothque <string.h> fournit une multitude de fonctions pratiques
pour le traitement des chanes de caractres. Voici une brve description des
fonctions les plus frquemment utilises.
3.3.1.
Affichage dune chane
Les fonctions puts et printf permettent dafficher lcran des chanes de

caractres, ces fonctions peuvent afficher aussi bien des chanes littrales que des
variables.
Syntaxe
/* prototype */
int puts (const char *ch);
int printf (const char *format, ch1, ch2,..., chn) ;
/* appel */
char *ch = " cest moi" ;
puts(ch) ;
printf("%s ", ch) ;

puts permet dafficher la chane ch lcran, suivie dun retour

chariot. Cette fonction renvoi le nombre de caractres de la chane.
printf permet dafficher les chanes ch1, ch2, , chn lcran

relativement lordre de conversion, %s, spcifi dans la chane
littrale format.
Exemple
#include <stdio.h>
char *vert1= " Il faut d'abord choisir le point";
char *vert2= " Pour tracer ensuite le cercle saint";
char vert3[]= " Autour de ma tte et de mon tre sain";
char
char
char
char
vert4[]= " D'une exactitude presque militaire";

*vert5= " Le point sert de centre et de repre";
*vert6= " Not zro, nul parfois je m'y perds";
auteur[]= "Dravitch";
main()
{
puts(vert1);
puts(vert2);
puts(vert3);
printf("\n\n");
printf ("%s\n%s\n%s\n", vert4, vert5, vert6);
printf("\n\n");
puts(auteur);
A.Zahi/DI/FSTF
91
3.3.2.
Saisie dune chane
Les fonctions gets et scanf permettent de lire des chanes de caractres

partir du clavier.
Syntaxe
/* prototype */
char* gets (char * ch);
int scanf (const char * format, ch1, ch2,..., chn) ;
/* appel */
char ch[10] ;
gets(ch) ;
scanf("%s", ch) ;

gets permet de lire jusqu la rencontre du retour chariot, puis range le

rsultat dans ch et remplace le retour chariot par le caractre \0.
Cette fonction renvoi la chane ou le caractre NULL.
scanf permet de lire ch1, ch2,..., chn lcran relativement lordre

de conversion, %s, spcifi dans la chane littrale format.
A la diffrence de la fonction gets(), scanf() ne permet pas de saisir

les chanes contenant des espaces.
Exemple
#include <stdio.h>
#include <stdlib.h>
main()
{
char nom[14] ;
char *plainte ;
printf (entrer votre nom ) ;
scanf(%s , nom) ;
plainte =(char*) malloc(50* sizeof(char)) ;
puts(entrer votre plainte ) ;
gets(plainte) ;
printf( votre dposition est la suivante:\n) ;
puts (plainte) ;
}
3.3.3.
Longueur dune chane
Syntaxe
/* prototype */
int strlen(const char * ch) ;
/* appel */
char* ch1;
char ch2[20] ;
A.Zahi/DI/FSTF
92
int len1 = strlen(ch1) ;

int len2 = strlen(ch2) ;
La fonction strlen renvoi le nombre de caractres de ch sans compter

le caractre nul.
Exemple
#include <stdio.h>
#include <string.h>
main()
{
char section[] = "Maitrises IEEA et TELECOM";
printf("Longueur :%d\n", strlen(section));
}
3.3.4.
Copie de chanes
Syntaxe
/* prototype */
char * strcpy( char * dest, char* source) ;
/* appel */
char * dest, *source ;
strcpy(dest, source) ;

strcpy copie la chane source dans dest caractre par caractre y

compris le caractre \0 et retourne la chane dest.
Remarque
Il faut rserver lespace ncessaire pour la chane destination
Il ny a pas daffectation des chanes de caractres, pour raliser cette

opration on utilise la fonction strcpy.
Exemple
#include <stdio.h>
#include <string.h>
main()
{
char dest[10];
char source[] = "Bonjour toto";
strcpy(dest, source);
printf("source : %s\n", source );
printf("copie : %s\n", dest);
printf("%s\n", dest);
}
A.Zahi/DI/FSTF
93
3.3.5.
Concatnation
Syntaxe
/* prototype */
char * strcat( char * dest, char* source) ;
/* appel */
char * dest, *source ;
strcat(dest, source) ;

strcat concatne la chane source la chane dest. Cette fonction

retourne la chane dest.
Exemple
#include <stdio.h>
#include <string.h>
main()
{
char st[25];
char espace[] = " ", s[] = "salut", t[] = "toto";
strcpy(st, s);
strcat(st, espace);
strcat(st, t);
printf("s : %s\n", s);
printf("t : %s\n", t);
printf("st: %s\n", st);
}
3.3.6.
Comparaison
Syntaxe
/* prototype */
int strcpy( char * s1, char* s2) ;
/* appel */
char * s1 , *s2 ;
int res= strcmp(s1, s2) ;

strcmp compare la chane s1 la chane s2. Les chanes sont

compares caractre par caractre en partant de la gauche. Cette
fonction retourne :
une valeur ngative ds quun caractre de la chane s1 est

plus petit que celui de la chane s2 .
une valeur positive ds quun caractre de la chane s1 est

plus grand que celui de la chane s2 .
La valeur 0 si les deux chanes sont identiques.

A.Zahi/DI/FSTF
94
Exemple
#include <string.h>
#include <stdio.h>
main()
{
char s1[] = "aaa", s2[] = "bbb", s3[] = "ccc";
int ptr;
ptr = strcmp(s2, s1);
if (ptr > 0)
printf("s2 est plus grande que s1 \n");
else
printf("s2 est plus petite que s1 \n");
ptr = strcmp(s2, s3);
if (ptr > 0)
printf("s2 est plus grande que s3 \n");
else
printf("s2 est plus petite que s3 \n");
}
Exercices
Ecrire les fonctions qui permettent de raliser les fonctions : strlen, strcmy, stcat,
et strcmp.
A.Zahi/DI/FSTF
95
Chapitre 3: Structures
Dans les chapitres prcdents, nous navons utilis que des objets simples
dont le type est prdfini par le langage. Pour reprsenter des objets complexes
et htrognes, le langage C offre des mcanismes, tels que les structures et les
numrations, qui permettent de construire de nouveaux types partir des types
de base. Lors de la manipulation de ces constructeurs, Il faut distinguer entre la
construction et lexploitation :
La construction, appele aussi dfinition, consiste dfinir la forme du

type quon veut construire : son nom, le nom et le type de chaque
composant.
Lexploitation correspond la dclaration et la manipulation des

variables de ce type.
1. Le mot cl typedef
Le mot cl typedef permet daffecter un nouveau nom un type existant,
quil soit simple ou compos.
Syntaxe
typedef

type nom_type ;
nom_type devient le nouveau nom du type, on peut ainsi dclarer

des variables laide de nom_type.
Exemple
#include <stdio.h>
#include <stdlib.h>
typedef float real ;
typedef char* string ;
void main()
{
/* les notes de ltudiant */
real note1 , note2 , moy ;
/* le nom de ltudiant */
string nom;
nom = (string) malloc(10*sizeof(char));
A.Zahi/DI/FSTF
96
printf("donner le nom de l'tudiant: ") ;

gets(nom);
printf("Saisir la note1 : ") ;
scanf ("%f", &note1);
printf("Saisir la note2 : ") ;
scanf ("%f", &note2);
moy = (note1+note2)/2;
printf(" Mr %s a eu une moyenne de %f ", nom, moy) ;
}
2. Enumrations
2.1. Dfinition dune numration
Une numration permet de construire un type partir dune liste de
valeurs. Cette liste constitue lensemble des valeurs prises par une variable de ce
type.
Syntaxe
typedef enum
{
enum_1,
enum_2,
.
.
enum_n,
} nom_enumeration ;
nom_enumeration le nom de lnumration.
enum_1, enum_2, , enum_n sont les identificateurs des

diffrentes constantes de lnumration.
Le compilateur affecte de faon automatique des valeurs entires,

chaque constante de lnumration, en partant de 0 et avec une
progression de 1.
Il est possible de fixer la valeur dun numrateur lors de la

dfinition; la progression reprend 1 pour lnumrateur suivant.
nom_enumeration devient le nom dun type, On peut ainsi faire les

dclarations suivantes :
nom_enumeration
v_1, v2, ;
Exemples
1. Construction dun type boolen
typedef enum
{
VRAI ,
FAUX,
} Bool ;
Enumrateur
VRAI
FAUXt
A.Zahi/DI/FSTF
Code
0
1
97
2. Constrction dun type couleur

typedef enum
{
rouge ,
vert,
bleu,
} Couleur ;
Enumrateur
rouge
vert
bleu
Code
0
1
2
Enumrateur
Lundi
Mardi
Mercredi
Jeudi
Vendredi
Samedi
Dimanche
Code
0
1
2
50
51
52
53
3. Constrction dun type jour

typedef enum
{
Lundi,
Mardi,
Mercredi,
Jeudi = 50,
Vendredi,
Samedi,
Dimanche,
} Jour;
2.2. Oprations sur les numrations

Les oprations possibles sur les numrations sont la comparaison et
laffectation simple. Un objet de type numration ne peut tre saisi ou affich
que sous forme dun entier.
Exemples
1. Recherche squentielle dans un tableau
#include <stdio.h>
typedef enum
{
vrai,
faux
} bool;
main()
{
int tab[10], n, i, v;
bool trouve;
printf(" Saisir la taille du tableau: ");
scanf("%d", &n);
for (i=0; i<n; i++)
{
printf("saisir tab[%d] = ", i);
scanf("%d", &tab[i]);
}
printf("Saisir la valeur v: ");
scanf("%d", &v);
i=0; trouve = faux;
while( i <=n && trouve == faux)
{
if(tab[i] == v) trouve = vrai;
i++;
}
if (trouve == vrai)
printf(" %d se trouve dans la case %d", v,i);
else
printf(" %d n'appartient pas au tableau", v);
}
A.Zahi/DI/FSTF
98
2. feu de circulation
#include <stdio.h>
typedef enum
{
rouge,
vert,
jaune,
} couleur;
void main()
{
couleur c;
printf("Saisir la couleur\n rouge: 0\n vert : 1 \n
jaune: 2\n\n choix: ");
scanf("%d",&c);
switch(c)
{
case rouge :printf("\n Arrter ");
break;
case vert
:printf("\nAvancer ");
break;
case jaune : printf("\nralentir ");

break;
default
: printf("\nFeu en panne");
break;
}
}
3.
Les Structures
Une structure permet de construire des objets forms par plusieurs

composantes htrognes i.e., de types diffrents. Les composantes dune
structure sappellent aussi membres ou champs.
3.1. Dfinition dune structure
Syntaxe
typedef struct
{
type_1 nom_champ_1 ;
.
.
type_n nom_champ_n ;
} ;

nom_structure
nom_structure cest un identificateur qui indique le nom de la

structure.
A.Zahi/DI/FSTF
99
nom_champ_1, nom_champ_2,...,nom_champ_n sont les noms

des membres qui caractrisent lobjet.
type_1, type_2,...,type_n, sont les types des diffrents membres.
Exemples
1. Construction dun type complexe
typedef struct
{
float real ;
float img ;
} complexe;
2. Construction dun type date

typedef struct
{
int annee;
int mois;
int jour;
} date;
3. Construction dun type point

typedef struct
{
float x ;
float y ;
} point;
3.2. Dclaration
La dclaration dune variable dun type construit obit aux mmes rgles et
la mme syntaxe que celles des types de bases.
Syntaxe
Variables statiques
nom_structure s1, s2 ;
Variables dynamiques
nom_structure *s1, *s2 ;

Il ne faut oublier, dans ce cas, dallouer de lespace mmoire

ces variables avant de les utiliser :
s1= (nom_structure *) malloc(sizeof(nom_structure));
A.Zahi/DI/FSTF
100
Exemples
complexe z1, z2 ;
complexe *z3, *z4 ;
z3= &z1 ;
z4= (complexe*) malloc(sizeof(complexe)) ;
3.3. Oprations sur les structures

Les structures peuvent tre manipules soit membre par membre ou comme
une entit indpendante.
3.3.1. Accs aux membres
Pour dsigner un membre dune structure on utilise loprateur de slection
point (.) pour les variables statiques et loprateur () pour les variables
dynamiques.
Syntaxe
nom_variable.nom_champ; /* Variable statique */
nom_variable->nom_champ; /* Variable dynamique */

nom_variable le nom de la variable et nom_champ le nom du membre

au quel on veut accder.
Les membres ainsi dsigns se comportent comme des variables

simples quon peut utiliser de diffrentes manires dans un programme :
Saisie :
scanf("%c", &nom_structure.nom_champs) ;
scanf("%c", &nom_structure->nom_champs) ;
avec c, le spcificateur de format associ au type du champ.
Affichage :
printf("%c", nom_structure.nom_champs) ;
printf("%c", nom_structure->nom_champs) ;
avec c, le spcificateur de format associ au type du champ.
Affectation
nom_structure.nom_champs)= expression ;
nom_structure->nom_champs)= expression ;
Elment dune instruction : facteur dune expression, instruction

du choix, boucle etc.
A.Zahi/DI/FSTF
101
Exemple
Ce programme saisit deux complexes, calcul leur somme et leur produit et
affiche les rsultas.
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
float real;
float img;
} complexe;
void main()
{
complexe z1;
complexe *z2;
complexe *som, prod;
/* saisie des variables*/
printf("\nSaisi du complexe z1\n");
printf("\tz1.real = "); scanf("%f",&z1.real);
printf("\tz1.img = "); scanf("%f",&z1.img);
z2 =(complexe*) malloc(sizeof(complexe));
printf("\tz1.real = "); scanf("%f",&z2->real);
printf("\tz1.img = "); scanf("%f",&z2->img);
/* calcul de la somme de z1 et z2*/
som=(complexe*) malloc(sizeof(complexe));
som->real = z1.real + z2->real;
som->img = z1.img + z2->img ;
/* calcul du produit de z1 et z2 */
prod.real = (z1.real*z2->real - z1.img*z2->img);
prod.img = (z1.real*z2->img + z1.img*z2->real);
/* affichage des rsultats */
printf("Somme
= %f + i%f ", som->real, som->img);
printf("\nProduit
=
%f
+
i%f
",
prod.real,
prod.img);
}
3.3.2. Initialisation
Une variable de type structure peut tre initialise lors de la dclaration par
une liste dexpressions constantes.
Syntaxe
typedef struct
{
.
.
} nom_structure;
nom_structure s1 = {exp_1, exp_2, , exp_n}
A.Zahi/DI/FSTF
102
Chaque expression exp_i est affecte au membre correspondant

nom_champ_i, exp_i doit tre une constante de mme type que
nom_champ_i
Exemple
complexe z1 = {8.,10.};
complexe z2 = {9.25,5.2};
3.3.3.
Affectation
Laffectation dune structure une autre de mme type permet de transfrer

les valeurs des champs de la structure source dans leurs homologues de la
structure destination.
Syntaxe
typedef struct
{
.
.
} nom_structure;
nom_structure s1, s2 ;
s1 = s2;
3.4. Structure paramtre dune fonction

Syntaxe
typedef struct
{
.
.
} nom_structure;
Prototype de la fonction
/* comme paramtre fixe */
void fonc1(nom_structure s1) ;
/* comme paramtre variable */
void fonc2(nom_structure *s1) ;
/* comme type de retour */
nom_structure fonc3() ;
A.Zahi/DI/FSTF
103
nom_structure *s1, s2, s3 ;
fonc1(*s1) ;
fonc1(s2) ;
fonc2(s1) ;
fonc2(&s2) ;
s3 = fonc3() ;
Exemple
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
float real;
float img;
} complexe;
/* fonction saisie d'un complexe*/
void saisie(complexe *z)
{
printf("\treal = "); scanf("%f",&z->real);
printf("\timg = "); scanf("%f",&z->img);
}
/* fonction calcul de la somme*/
void somme(complexe z1, complexe z2, complexe *s)
{
s->real = z1.real + z2.real;
s->img = z1.img + z2.img ;
}
/* fonction calcul du produit*/
complexe produit(complexe z1, complexe z2)
{
complexe p;
p.real = (z1.real*z2.real - z1.img*z2.img);
p.img = (z1.real*z2.img + z1.img*z2.real);
return p;
}
/* fonction affichage */
void affiche(complexe z)
{
if(z.real == 0)
if(z.img == 0)
printf("0");
else
if(z.img == 1)
printf("i");
else
printf("i%1.2f",z.img);
else
if(z.img == 0)
printf("%10.2f", z.real);
else
if(z.img == 1)
printf("%1.2f + i",z.real);
else
printf("%1.2f + i%1.2f",z.real,
z.img);
}
A.Zahi/DI/FSTF
104
void main()
{
complexe z1;
complexe *z2;
complexe *som, prod;
/* saisie de complexe*/
saisie(&z1);
z2 =(complexe*) malloc(sizeof(complexe));
saisie(z2);
/* calcul de la somme de z1 et z2*/
som=(complexe*) malloc(sizeof(complexe));
somme(z1,*z2,som);
/* calul du produit de z1 et z2 */
prod = produit(z1,*z2);
printf("\n");
printf("Somme
= ");affiche(*som);
printf("\nProduit
= ");affiche(prod);
}
3.5. Tableau de structures

Un tableau de structure est un tableau dont les lments sont des structures.
Syntaxe
#define CAP 100
typedef struct
{
.
.
.
} nom_structure;
nom_structure T[CAP];

T le nom du tableau.
nom_structure type des lments du tableau.
T[i] reprsente llment de rang i, cest une variable de type

nom_structure,
Pour accder au jme champ de llment i on crit :

T[i].nom_champ_j.
A.Zahi/DI/FSTF
105
Exemple
Ce programme saisi un tableau de complexe et affiche llment qui le plus petit
module
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define CAP 10
typedef struct
{
float real;
float img;
} complexe;
/* fonction saisie d'un complexe*/
void saisie(complexe *z)
{
printf("\treal = "); scanf("%f",&z->real);
printf("\timg = "); scanf("%f",&z->img);
}
/* fonction calcul du module */
float module(complexe z)
{
float m;
m=sqrt(z.real*z.real + z.img*z.img);
return m;
}
/* fonction affiche complexe */
void affiche(complexe z)
{
if(z.real == 0)
if(z.img == 0)
printf("0");
else
if(z.img == 1)
printf("i");
else
printf("i%1.2f",z.img);
else
if(z.img == 0)
printf("%10.2f", z.real);
else
if(z.img == 1)
printf("%1.2f + i",z.real);
else
printf("%1.2f + i%1.2f",z.real,
z.img);
}
/* saisie dun tableau de complexes */
void saisieTab(complexe T[], int n)
{
int i;
for (i=0; i<n; i++)
{
printf("\nSaisi du complexe Tab[%d] \n",i+1);
saisie(&T[i]);
}
}
A.Zahi/DI/FSTF
106
/* function maximum */
int Max_Mod(complexe T[], int n)
{
int ind;
float max;
max =-1;
ind = 0;
for (i=0; i<n; i++)
{
mod = module(T[i]);
if (mod > max)
{
max= mod;
ind = i;
}
return ind;
void main()
{
complexe Tab[CAP];
int i,ind,n;
float mod, max;
printf("saisir la taille du tableau");
scanf("%d", &n);
saisieTab(Tab,n);
ind = Max_Mod(Tab, n);
affiche(Tab[ind]);
}
3.6. Tableau membre dune structure

Une structure peut contenir un ou plusieurs tableaux comme membres, les
tableaux peuvent contenir tous les types de donnes C.
Syntaxe
typedef struct
{
type_tab T[10];
.
.
.
} nom_structure ;

Pour accder aux lments du tableau, on utilise les oprateurs

daccs (.) et () et loprateur dindexation ([]) :
nom_structure *s1, s2 ;
s1->T[i]
s2.T[i]
Exemple
A la fst, pour chaque tudiant on retient les informations suivantes: le nom,
le code, les notes des 12 modules, et la moyenne gnrale. Le programme cidessous saisit les informations dun tudiant, calcul sa moyenne gnrale, calcul
le nombre de modules non valids et affiche sil est admis
A.Zahi/DI/FSTF
107
#include <stdio.h>
typdef struct
{
char nom[10] ;
int CNE;
float mod [12] ;
float Moy ;
} etudiant;
/* saisi dun tableau de rel*/
void saisiMod(float t, int n)
{
int i;
for (i=0; i<n; i++)
{
printf("\nSaisir le module M[%d] \n",i+1);
scanf("%f",&t[i]);
}
}
/* saisie dun tudiant tudiant */
void saisie( etudiant * etu)
{
printf ("entrer le nom ") ;
gets(etu->nom) ;
printf("entrer le CNE") ;
scanf("%d",&etu->CNE) ;
printf("entrer les des 12 modules ") ;
saisiMod(etu->mod, 12);
}
/* calcul de la moyenne gnrale*/
void cal_moy(etudiant *etu)
{
int i;
etu->Moy=0.0;
for (i=0; i<12; i++)
etu->Moy += etu->mod[i];
etu->Moy = (etu->Moy)/12;
}
/* admission */
void admis(etudiant etu)
{
if ( etu.moy >=10)
return 1 ;
else
return 0
}
void main()
{
etudiant e;
saisi(&e);
cal_moy(&e);
if( admis(e))
printf ("Admis") ;
else
printf ("Ajourn ") ;
}
A.Zahi/DI/FSTF
108
3.7. Structures imbriques

Une structure peut contenir un membre de type structure, noter que la
structure membre doit tre dfinie avant la structure qui la contient.
Syntaxe
typedef struct
{
.
.
} st_memmbre ;
typedef struct
{
st_membre s1;
st_membre s2;
.
.
.
} nom_structure;
Exemple
#include<stdio.h>
struct date
{
int jour ;
int mois ;
int annee ;
} ;
struct livre
{
char titre [30] ;
char auteur[14] ;
int code ;
date d_entre ;
date d_sortie ;
} ;
/* saisie dune date */
void saisieDate(date *d)
{
printf (entrer le jour) ;
scanf("%d " &d->jour) ;
printf(entrer le mois) ;
scanf("%d " &d->mois) ;
printf(entrer lanne ) ;
scanf("%d " &d->annee) ;
}
A.Zahi/DI/FSTF
109
/* lecture dun livre */

void saisielivre(livre * l)
{
printf (entrer lauteur ) ;
gets(l->auteur) ;
printf (entrer le titre) ;
gets(l->titre) ;
printf(entrer le Code) ;
scanf(%d,&l->code) ;
printf("entrer la date dentre ") ;
saisiDate(&l->d_entree) ;
printf("entrer la date de sortie ") ;
saisiDate(&l->d_sortie);
}
/* fonction recherche du code dun livre par le titre dans
un tableau de livre*/
int RechCode(livre L[], int n, char* titre)
{
int i ;
for (i=0, i<n ; i++)
{
if(strcmp((L[i].Titre, titre))
return L[i].Code;
}
return -1;
}
main()
{
livre L[50] ;
int n, i ;
char titre[30] ;
printf("Saisir le nombre de livres") ;
sacnf("%d ", &n) ;
/* Saisie des livres */
for(i=0 ; i<n ; i++)
saisielivre(&L[i]) ;
/* Recherche dun livre */
printf("Saisir le titre") ;
gets(titre) ;
printf("Le code est : ", RechCode(L,n,titre)) ;
}
A.Zahi/DI/FSTF
110
Chapitre 4: Fichiers
Un programme communique avec son environnement extrieur (Utilisateurs,

Programmes, Machines, etc.,) travers des dispositifs appels priphriques. En
C, lchange de linformation entre un programme et les priphriques se fait par
lintermdiaire des fichiers. Tous les priphriques sont considrs comme des
fichiers, le programme lit les donnes sur un priphrique et crit les rsultats sur
un priphrique. Dans ce chapitre nous allons prsenter comment manipuler les
fichiers dans un programme C.
1.
Dfinition
Un fichier constitue lentit de base pour conserver linformation sur un

support de stockage (disque dur, disquette, CD, flash disque etc.,). Cest une
collection dinformations homogne vue structure comme une suite doctets ou
de caractres. Sur un support de stockage, un fichier est identifi par une chane
de caractres qui dsigne le nom physique du fichier, ce nom est gnralement
attribu par lutilisateur.
Il existe deux fichiers qui sont dfinis par dfaut pour tous les
programmes : le fichier stdin, qui est associ avec lentre standard (le clavier) et
le fichier stdout qui est associ la sortie standard (lcran).
2.
Mmoire tampon
Pour des raisons de performances, les accs un fichier se font par

lintermdiaire dune mmoire tampon appele buffer. Cest une zone de la
mmoire centrale rserve un ou plusieurs octets ou caractres du fichier. Le
programme rcupre, les informations en provenance du fichier, partir du
buffer et dpose, les informations destination du fichier, sur le buffer.
Lutilisation de la mmoire tampon permet de rduire le nombre daccs au
support de stockage et minimise par suite les dplacements de la tte de
lecture/criture.
A.Zahi/DI/FSTF
111
Programme C
Instructions
+
Donnes
Mmoire
tampon
tte
l/e
Support
de
stockage
Mmoire
centrale
Figure 18 : Procdure daccs un fichier
3.
Accs un fichier
3.1. Le type FILE*

FILE* est un pointeur sur une structure dclare dans le fichier en-tte
<stdio.h>. Cette structure contient les informations telles que ladresse de la
mmoire tampon, la position courante de la tte de lecture/criture, le type
daccs au fichier, tat derreur etc., Un programme doit dclarer un pointeur sur
cette structure pour pouvoir accder aux fichiers.
Syntaxe
FILE * flot;
3.2. Ouverture/fermeture
Pour tablir la connexion avec le fichier, le programme notifie le systme
dexploitation par la fonction douverture fopen, qui reoit le nom physique du
fichier comme paramtre, le systme gnre ensuite un bloc de type FILE et
retourne son adresse au programme. La connexion est coupe laide de la
fonction de fermeture fclose .
Syntaxe
FILE *flot;
flot= fopen(non_physique, mode_ouverture) ;
fclose(flot) ;
A.Zahi/DI/FSTF
112
flot pointeur sur la structure qui contient les informations au sujet

du fichier
non_physique cest une chane de caractres qui contient le nom

du fichier physique.
mode_ouverture cest un pointeur sur une chane de caractres qui

indique le mode douverture du fichier. Elle peut tre lune des
chanes suivantes :
Mode
r
Position
dbut
dbut
fin
rb
dbut
wb
dbut
ab
fin
r+
dbut
w+
dbut
a+
fin
r+b ou rb+
dbut
w+b ou wb+
dbut
a+b ou ab+
fin
Signification
Ouverture dun fichier texte en
lecture
criture
criture
Ouverture dun fichier binaire en
lecture
criture
criture
lecture/ criture
lecture/ criture
lecture/criture
lecture/criture
lecture/criture
lecture/ criture
La fonction fopen retourne une valeur de type pointeur vers FILE,

si louverture a russi la valeur retourne permet de reprer le
fichier, dans le cas contraire la valeur retourne est la constante
NULL.
La fonction fclose permet de fermer le fichier repr par flot. Elle

retourne la valeur 0 si le fichier a t ferm, et rend la valeur EOF
sil y a eu une erreur.
A.Zahi/DI/FSTF
113
Exemple
#include <stdio.h>
main(()
{
FILE * flot ;
flot= fopen(fichier.dat, r) ;
if(flot==NULL)
printf(erreur douverture ) ;
else
/* traitement sur le fichier*/
....
fclose(flot) ;
}
4. Lecture /criture
4.1. Lecture et criture par caractre
Les fonctions fgetc et fputc permettent de lire et dcrire un caractre sur
un fichier.
Syntaxe
FILE *flot;
int car ;
char car ;
/* erreur */
car=fgetc (flot) ;
fputc(flot) ;

flot est un pointeur de type FILE*, il pointe sur le fichier partir

duquel se fait la lecture ou sur lequel se fait lcriture.
car est de type int, cest le caractre crire dans le fichier ou dans
lequel on rcupre le caractre lu partir du fichier.
Exemple
#include <stdio.h>
main()
{
int car ;
FILE* f;
/* criture dans le fichier test.dat*/
f= fopen ("test.dat", "w");
if(f != NULL){
while ( (car=getchar()) != '\n')
fputc(car,f );
}
fclose(f);
/* lecture du fichier test.dat*/
f= fopen ("test.dat", "r");
if(f != NULL)
{
while ( (car= fgetc(f)) !=EOF)
printf("%c" , car);
}
fclose(f);
}
A.Zahi/DI/FSTF
114
4.2. Lecture et criture par chanes de caractres

Les fonctions fgets et fputs permettent de lire et dcrire des chanes de
caractre sur un fichier.
Syntaxe
FILE *flot;
char * chaine ;
fgets(chaine,nb, flot) ;
fputs(chaine, flot) ;
chaine est un pointeur vers char qui contient la chane lire ou

crire.
flot est un pointeur de type FILE*, il pointe sur le fichier partir

duquel se fait la lecture ou sur lequel sa fait lcriture.
nb est la taille en octets du tableau point par chaine.
Exemple
#define BUFSIZE 10
#include <stdio.h>
main()
{
char* ch1="Abou Bakker Elkawarizmi\n";
char* ch2="Alain Turing \n";
char bf[BUFSIZ+1];
FILE* f;
/* criture dans le fichier chaine.dat*/
f= fopen ("chaine.dat", "w");
if(f != NULL)
{
fputs(ch1,f);
fputs(ch2,f);
}
fclose(f);
/* lecture du fichier chaine.dat*/
f= fopen ("chaine.dat", "w");
if(f != NULL)
{
while (fgets (bf,sizeof(bf),f))
printf("%s\n",bf);
}
fclose(f);
}
4.3. Lecture et criture formates

Les fonctions fscanf et fprintf permettent, de lire et dcrire des donnes
avec conversions de type.
A.Zahi/DI/FSTF
115
Syntaxe
fscanf (f, format,&var_1, &var_2,...) ;
fprintf(f, format ,var_1, var_2 ...);

f est un pointeur de type FILE*, il pointe sur le fichier partir

duquel se fait la lecture ou sur lequel se fait lcriture,
format cest une chane de caractre qui indique ce qui doit tre
crit ou lu. Cette chane contient des caractres constants et des
spcificateurs de formats commenant par le caractre %, dcrivant
comment les paramtres var_i doivent tre crits
var_i une variable qui contient une valeur lire ou crire
Exemples
1.
Lecture et criture dune seule structure dans un fichier

#include <stdio.h>
struct Foncti
{
int Code;
float Sal;
char Nom[15];
};
/* criture dans le fichier*/
void Ecriture(char * nom, Foncti, fon)
{
f= fopen (nom, "w");
if(f != NULL)
{
fprintf(f,"%d\n",fon.Code);
fprintf (f,"%f\n",fon.Sal);
fprintf (f,"%s\n",fon.Nom);
}
fclose(f);
}
/* lecture partir du fichier */
void lecture(char* nom, Foncti *g)
{
f= fopen (nom, "r");
if(f != NULL)
{
fscanf (f,"%d\n", &g->Code);
fscanf (f,"%f\n", &g->Sal);
fscanf (f,"%s\n", &g->Nom);
}
fclose(f);
}
main()
{
Foncti fon ={145, 5000.00, "Ali"},g;
FILE* f;
/* criture dans le fichier "fonc.dat" */
Ecriture("fonc.dat",fon)
/* lecture partir du fichier*/
lecture("fonc.dat", &g) ;
printf("%d %s %f\n",g.Code,g.Nom,g.Sal);}
A.Zahi/DI/FSTF
116
2.
Lecture et criture dun tableau de structures dans un fichier

#include <stdio.h>
struct Foncti
{
int Code;
float Sal;
char Nom[15];
};
/* criture du tableau dans le fichier */
void EcrireTab(char *nom, Foncti fonc[], int nb)
{
if(f != NULL)
{
for(int i =0; i<nb; i++)
{
fprintf(f,"%d ",fon[i].Code);
fprintf (f,"%f ",fon[i].Sal);
fprintf (f,"%s\n ",fon[i].Nom);
}
}
fclose(f);
}
/* Lecture du tableau partir du fichier */
void LireTab(char *nom, Foncti d[], int *nb)
{
Foncti g;
if(f != NULL)
{
*nb=0;
while (!feof(f))
{
fscanf(f,"%d\n",&g.Code);
fscanf(f,"%f\n",&g.Sal);
fscanf(f,"%s\n",&g.Nom);
d[Nb]=g;
(*nb)++;
}
}
fclose(f);
}
main()
{
Foncti fon[] ={ {145, 5000.00, "Ali"}, {148,
3000.00, "Doudou"}, {150, 2000.00, "Dadi"}};
Foncti d[10],g;
int nb;
FILE* f;
EcrireTab("fonc.dat", fonc,3) ;
LireTab("fonc.dat", d,&nb) ;
for(int i=0; i<nb; i++)
printf("%d %s %f\n", d[i].Code, d[i].Nom,
d[i].Sal);
}
A.Zahi/DI/FSTF
117
4.4. Lecture et criture par blocs

Les fonctions fread et fwrite permettent de lire et dcrire des blocs de
donnes tels que les structures et des tableaux.
Syntaxe
fread(p, t , n, f) ;
fwrite(p, t , n, f) ;

p est un pointeur gnrique qui pointe sur le bloc lire ou crire.
t indique la taille du bloc lire ou crire.
n indique le nombre de blocs lire ou crire,
f est un pointeur de type FILE*, il pointe sur le fichier partir

duquel se fait la lecture ou sur lequel se fait lcriture,
Ces fonctions retournent le nombre de blocs traits.
Exemples
1.
Lecture et criture dune seule structure dans un fichier

#include <stdio.h>
struct Foncti
{
int Code;
float Sal;
char Nom[15];
};
/* criture dans le fichier*/
void Ecriture(char * nom, Foncti, *fon)
{
if(f != NULL)
fwrite (fon, sizeof(Foncti), 1,f);
fclose(f);
}
/* lecture partir du fichier */
void lecture(char* nom, Foncti *g)
{
if(f != NULL)
fread(g, sizeof(Foncti), 1,f);
fclose(f);
}
main()
{
Foncti fon ={145, 5000.00, "Ali"} , g;
FILE* f;
/* criture dans le fichier fonc.dat */
Ecriture("fonc.dat",&fon)
/* lecture partir du fichier fonc.dat */
lecriture("fonc.dat",&g)
printf("%d\n",g.Code);}
A.Zahi/DI/FSTF
118
2.
Lecture et criture dun tableau de structures dans un fichier

#include <stdio.h>
struct Foncti
{
int Code;
float Sal;
char Nom[15];
};
/* criture du tableau dans le fichier */
void EcrireTab(char *nom, Foncti fonc[], int nb)
{
if(f != NULL)
{
fwrite(fon, sizeof(Foncti), nb, f);
}
fclose(f);
}
/* Lecture du tableau partir du fichier */
void LireTab(char *nom, Foncti d[], int nb)
{
Foncti g;
if(f != NULL)
fread(d, sizeof(Foncti), nb,f);
fclose(f);
}
main()
{
Foncti fon[] ={ {145, 5000.00, "Ali"}, {148,
3000.00, "Doudou"}, {150, 2000.00, "Dadi"}};
Foncti d[10];
/*
/*
int i;
FILE* f;
criture du tableau dans le fichier */
EcrireTab("fonct.dat", fonc, 3) ;
fclose(f);
Lecture du tableau partir du fichier */
Liretab("fonct.dat", d,3) ;
i=0 ;
while (i<3)
{
printf("%d%f%s\n",d[i].Code,d[i].sal,d[i].Nom);
i++;
}
5.
Accs directe
Pour chaque fichier ouvert est associ un indicateur de position qui indique
quel endroit du fichier aura lieu la prochaine opration (lecture/criture). Cette
position est donne en nombres doctets partir du dbut du fichier. Par dfaut,
les fonctions prcdentes travaillent en mode squentiel, et mettent jour cet
indicateur par incrmentation automatique. En effet, chaque lecture ou criture
seffectue partir dune position courante, et incrmente cette position du
nombre de caractres lus ou crits.
A.Zahi/DI/FSTF
119
Les fonctions rewind, ftell, et fseek permettent deffecteur un contrle sur

lindicateur de position, on peut par suite faire un accs alatoire au fichier.
Syntaxe
rewind(f)
ftell(f) ;
fseek(f, dec, position)

La fonction rewind permet de placer lindicateur de position au

dbut du fichier.
La fonction ftell permet de retourner la valeur de lindicateur de

position.
La fonction fseek permet de donner une nouvelle valeur

lindicateur de position.
dec valeur du dcalage est exprime en octets,
position celle partir de la quelle est calcul le dcalage, elle

sexprime laide des constantes dfinies dans le fichier <stdio.h>,
SEEK_SET dbut de fichier,

SEEK_CUR position courante.
SEEK_END fin de fichier.
Exemple
#include <stdio.h>
#define PAS 10
char mess[]="abcdefghijklmnopqrstuvwxyz";
int main(void)
{
FILE *f;
char temp[PAS];
/* Ecriture dans le fichier */
f=fopen("text.txt","w");
if(f != NULL)
fprintf(f,"%s",mess);
fclose(f);
/* fonction ftell */
f=fopen("text.txt","r");
printf (" Avant la lecture\n \t position :%d\n",
ftell(f));
fgets(temp,PAS,f);
printf (" \n Apres la 1 er lecture\n");
printf("\t caractere :%s\t position : %d\n", temp,
ftell(f));
fgets(temp,PAS,f);
printf (" \n Apres la 2 eme lecture \n");
printf("\t caractere : %s \t position : %d\n", temp,
ftell(f));
fgets(temp,PAS,f);
printf (" \nApres la 3 eme lecture \n");
ftell(f));
A.Zahi/DI/FSTF
120
/* fonction rewind */
rewind(f);
printf ("\n Apres rewind, la position est: %d\n",
ftell(f));
fgets(temp,PAS,f);
printf (" \n1 er lecture Apres rewind \n");
ftell(f));
fclose(f);
getchar();
}
A.Zahi/DI/FSTF

Langage 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

Langage C

Transféré par

Droits d'auteur :

Formats disponibles

Universit Sidi Mohamed Ben Abdellah

Facult des Sciences et Techniques Fs

Table des matires

2.2.1. Instructions directement excutables ______________ 33

7.1.3. Imbrication des tests____________________________ 50

1.4.3. Indexation du tableau __________________________ 81

Chapitre 4: Fichiers ....................................................................................... 110

Figure 1 : Schma dun algorithme

1.2. Structure dun algorithme

Partie dclaration : contient les objets (donnes et rsultats) utiliss

Partie traitement : contient les instructions (actions) qui permettent de

La forme gnrale dun algorithme se prsente comme suit:

1.3. Dmarche mthodologique

La phase danalyse, consiste :

Identifier les paramtres qui dcrivent le problme i.e., les

Formuler le problme en termes, de formules, dquations

La phase de conception, consiste :

Reprsenter les paramtres du problme par des objets

Exprimer les mthodes de rsolution sous forme dinstructions

Exemple : Calculer le pgcd de deux entiers

Objets dun algorithme

Un identificateur qui permet de dsigner un objet dans lalgorithme.

Un type qui permet de dfinir lensemble des valeurs susceptibles

Un tat qui correspond la valeur prise un instant de lexcution de

Un identificateur ne doit contenir que les caractres alphabtiques, les

Un identificateur doit toujours commencer par un caractre

Un identificateur ne doit pas contenir les caractres accentus et

Un identificateur doit reflter l'objet auquel il est associ. Par

Identificateur non valide

2.2. Types prdfinis

Entier : cest lensemble des entiers positifs, nuls ou ngatifs. Les

Boolen, un objet de ce type ne peut prendre que deux valeurs : VRAI ou

Oprateurs logiques : et, ou et non.

Rel, ce type correspond lensemble des rels. Les oprations quon

Oprations arithmtiques: +, -, * /, div : division entire et mod :

Caractre, regroupe le jeu de caractre d'une machine. Il est constitu par

Dclaration dune constante

Dclaration dune variable

Expressions arithmtique, ce sont des expressions formes par des

Expressions logiques : ce sont les expressions formes par des objets

( i<= n et exist = vraie)

Formulation de la condition dadmission, des tudiants du Deug,

3. Instructions dun algorithme

A gauche du symbole d'affectation il y a toujours une variable, les

La variable gauche du symbole d'affectation et la valeur affecte

3.2. Lecture /criture

L'instruction d'criture crire permet dafficher sur un priphrique de

Ecrire un algorithme qui permet de saisir : le prix hors taxe PHT, le

La surface dun triangle de cts a , b et c est donne par :

Ecrire un algorithme qui calcule laire. On suppose quon dispose

La figure 2 montre le fonctionnement de linstruction si sans sinon.

Figure 2 : Organigramme de linstruction si sans sinon

2. Calcul du maximum de deux entiers

Choix avec alternative

Condition est une expression logique si elle est vraie alors on

La figure 3 montre le fonctionnement de linstruction si avec sinon.

Figure 3 : Organigramme de linstruction si avec sinon

2. Lalgorithme suivant saisit deux entiers, x et y , et dcide si x est divisible

3. Ecrire un algorithme qui saisit deux points, A = (x1 , y1 ) et B = (x 2 , y 2 ) ,

4. Ecrire un algorithme qui saisit trois rels x , a et b et affiche limage de

Lexcution de cette instruction se base sur le fait quun sinon

Une reprsentation arborescente permet didentifier tous les cas

Figure 4 : Reprsentation graphique du choix imbriqu