Annexe 1

INTRODUCTION
AU
LANGAGE
C




Historique

• Le
langage
C
a
été
inventé
en
1972
par
Dennis
Ritchie
et
Ken
Thompson
(AT&T
Bell
Laboratories)

pour
réécrire
Unix
et
développer
des
programmes
sous
Unix.


• En
1978,
Brian
Kernighan
et
Dennis
Ritchie
publient
la
définition
classique
du
C
dans
le
livre
«
The

C
Programming
language
»
.



C’est
une
norme
ANSI
(ANSI‐C)
depuis
1989
et
un
standard
ISO
depuis
1990.



 Langage
 de
 haut
 niveau,
 structuré,
 portable
 et
 modulaire
 grâce
 à
 ses
 nombreuses
 librairies

standard
(stdio,
string,
math,
etc.).



Généralités

Un
programme
est
un
ensemble
de
fichiers
qui
peuvent
être
édités,
compilés
et
exécutés
:

• Compilation
 :
 traduction
 d’un
 programme
 d’un
 langage
 source
 (haut
 niveau)
 vers
 un

langage
destination
(plus
bas
niveau).


• Exécution
 d’un
 compilateur
:
 génère
 un
 programme
 exécutable
 à
 partir
 d’un
 ou
 de

plusieurs
fichiers
contenant
du
code
source.


Tout
programme
C
est
composé
d'un
programme
principal
(fonction
main).

Variable
=
objet
manipulé
par
le
programme,
qui
sert
à
nommer
un
espace
réservé
en
mémoire.


À
chaque
variable
est
associé
un
type
et
sa
valeur
actuelle
:

• Le
type
est
défini
au
moment
d’une
déclaration
:
une
instruction
composée
d’un

spécificateur
de
type
et

d’une
liste
d’identificateurs
séparés
par
une
virgule.

• La
valeur
d’une
variable
peut
être
modifiée
pendant
l’exécution
du
programme
par
des

instructions
d’affectation.


Une
expression
est
composée
d’une
ou
plusieurs
opérandes
(constantes,
variables,
etc.)
reliés
par

zéro
ou
plusieurs
opérateurs.
A
chaque
expression
est
associé
un
type.


Une
instruction
est
une
expression
qui
se
termine
par
un
point‐virgule
‘;’.


Un
bloc
est
une
instruction
composée
:


• d’une
accolade
ouvrante
{


• d’une
liste
de
déclarations
de
variables

• d’une
liste
d’instructions

• d’une
accolade
fermante
}


Un
commentaire
est
encadré
par
des
délimiteurs
/*
et
*/
(//
commentaire
par
ligne).

Une
variable
globale
est
définie
et
utilisable
par
toutes
les
fonctions
définies
dans
le
programme.

Une
variable
locale
est
définie
et
utilisable
qu’à
l’intérieur
du
bloc
d’instructions
d’une
fonction.



Directives
du
préprocesseur


Une
instruction
du
préprocesseur
:
commence
par
#

Une
constante
est
définie
:
#define
NOM_CONST
constante


• #include
<nom
fichier>
:
inclusion
d’un
fichier
qui
se
trouve
dans
les
répertoires
standard.

• #include
"nom
fichier"
:
inclusion
d’un
fichier
qui
se
trouve
dans
les
répertoires
définis
dans

l’environnement.



Quelques
bibliothèques
standard
ANSI

stdio.h

 Gestion
des
entrées
sorties
(io
pour
Input/Output)


 
 
printf,
scanf,
getc,
putchar,
fopen,…

stdlib.h
 Traitements
courants
ou
utilitaires


 
 
rand,
malloc,
atoi,…

string.h

 Manipulation
de
chaînes
de
caractères


 
 
strcpy,
strcat,
strcmp,
strlen,…

math.h

 Traitements
mathématiques


 
 
pow,
sqrt,
exp,...

time.h


 Manipulation
des
primitives
de
temps
(date,
heure,
etc.)


 
 
clock,
time,
mktime,
localtime,…





Lecture
et
Écriture
sur
les
entrées/sorties
standard
(stdin/stdout)

Fonction
:
printf
("…format…",
e1,
e2,
....)



affichage
à
l’écran
(écriture
vers
la
sortie
standard).

Fonction
:
scanf
("…format…",&v1,&v2,...)



saisie
de
valeurs
à
l’écran
(lecture
de
l’entrée
standard)
en
accord
avec
un
format.

Fonction
:
int
putchar
(int
c)



affichage
d’un
caractère
à
l’écran.

Fonction
:
int
puts
(char
*s)


affichage
d’une
chaîne
de
caractères
à
l’écran
(en
ajoutant
le
caractère
‘\n’).

Fonction
:
int
getchar
(void)


saisie
d’un
caractère
à
l’écran.

Fonction
:
int
gets
(char
*s)


saisie
d’une
chaîne
de
caractères
à
l’écran.



Séquences
d’échappement

\n

 nouvelle
ligne


\r

 retour
chariot


\t

 tabulation
horizontale


\f

 saut
de
page


\v

 tabulation
verticale


\a

 signal
d’alerte


\b

 retour
arrière




Spécifications
de
conversion


Format

 Type

 
 Explication

%d,
%i

 
 int

 
 notation
décimale
signée.


%u

 
 int

 
 notation
décimale
non
signée.


%c

 
 int

 
 un
seul
caractère
après
conversion
en
unsigned
char.


%s

 
 char
*

 
 chaîne
de
caractères
jusqu’au
premier
‘\0’.


%f,
%2.7f

 double


 notation
décimale
de
la
forme
[‐]mmm.dddddd
(6
par
défaut).


%e,E

 
 double


 notation
scientifique
de
la
forme
[‐]m.ddddddE[+‐]xx.


%x

 
 int,double
 notation
hexadécimale.


INSTRUCTIONS
SIMPLES,
STRUCTURES
DE
CONTRÔLE
&
ITÉRATIVES




Types
C

Types
arithmétiques
:

• ensembles
des
nombres
entiers
:



o entiers
:
int, short, long

o caractères
:
char 

o types
énumérés
(ensembles
fini
d’entiers)
:
enum


• ensembles
des
nombres
à
virgule
flottante
:
flottants
ou
réels
(float,
double)
































 

Type
de
donnée
 Signification
 Taille
(octets)
 Plage
de
valeurs

char
 Caractère
 1
 −128
à
127

unsigned
char
 Caractère
non
signé
 1
 0
à
255

short
int
 Entier
court
 2
 −32
768
à
32
767

unsigned
short
int
 Entier
court
non
signé
 2
(proc.
16
bits)
 0
à
65
535

(signed)
int
 Entier
 2
(proc.
16
bits)
 −32
768
à
32
767

4
(proc.
32
et
64
bits)
 −2
147
483
648
à
2
147
483
647


unsigned
int

 Entier
non
signé
 2
(proc.
16
bits)
 0
à
65
535


4
(proc.
32
et
64
bits)
 0
à
4
294
967
295

long
int
 Entier
long
 4
 −2
147
483
648
à
2
147
483
647

8
(proc.
64
bits)
 −9
223
372
036
854
775
808
à


9
223
372
036
854
775
807

unsigned
long
int
 Entier
long
non
signé
 4
 0
à
4
294
967
295

−38 38
float
 Flottant
(réel)
 4
 1.2
∗
10 
à
3.4
∗
10 

double
 Flottant
double
 8
 2.2
∗
10−308
à
1.8
∗
10308

long
double
 Flottant
double
long
 12
 3.4
∗
10−4932
à
1.2
∗
104932



Types
dérivés
:

• tableaux
:
[ ]


• enregistrements
ou
structures
:
struct 

Type
void
:

• ensemble
vide
(sans
valeur)
:
void



Opérations
arithmétiques
binaires
:

 Opérations
arithmétiques
unaires
:


Symbole
 Signification
arithmétique
 Symbole
 Signification
arithmétique

+
 addition
 ++

 incrémentation
(types
entiers)

‐
 soustraction
 ‐‐

 décrémentation
(types
entiers)

*
 multiplication
 Les
instructions
i++
;
et
i­­
;
sont
équivalentes

/
 division
 aux
instructions
d’affectation
i=i+1;
et
i=i­1;

%
 reste
de
la
division
 i++
et
++i
sont
équivalents
à
i=i+1
;

Si
les
deux
arguments
sont
de
types
entiers,

 j=i++⇔
j=i
et
i=i+1
(post‐incrémentation)

/
correspond
à
la
division
euclidienne
entière.

 j=++i
⇔
i=i+1
et
j=i
(pré‐incrémentation)

Le
résultat
de
la
division
est
indéfini,
si
le
second
 

opérande
vaut
0.




Opérateurs
de
comparaison
:

 Opérations
booléennes
:


Symbole
 Signification
arithmétique
 Symbole
 Signification
arithmétique

==
 égalité
 a
&&
b
 et
(conjonction)

<
 inférieur
 a
||
b
 ou
(disjonction)

>
 supérieur
 
 !
a
 non
(négation)

<=
 inférieur
ou
égal

>=
 supérieur
ou
égal


 !=
 différent



Structures
de
contrôle
ou
conditionnelles


if
(condition)
{

 if
(condition)


 instructions_if
;

 
instruction_if
;

}
 

else
{

 Résultat
de
l’expression
logique
(ou
condition)



 instructions_else
;

 =>
un
booléen
(0
ou
différent
de
0)

}

 













switch
(variable
(ou
expression))


{
 


 case
valeur_1
:
instruction_1;


 


 
 
 break;


 case
valeur_2
:
instruction_2;


 
 
 break;



 case
valeur_3
:
instruction_3;


 
 
 break;



 default
:
instruction
par
défaut;

}




Structures
itératives

while
(condition)
{

 for
(init_compteur;
condition_compteur;
avance_compteur)
{



 instructions_while

 instructions_for


}

 }



 

do
{


instructions_do


}
while
(condition);






FONCTIONS



Syntaxe
de
la
définition
d’une
fonction


type_res
ma_fonction
(
type_arg1
arg1,
type_arg2
arg2,
...,
type_argn
argn
)
{


déclarations_de_variables_internes


instructions_fonction


return
expr;


}


L’instruction
return
expr
;
permet
de
quitter
la
fonction
:


–
Elle
peut
apparaître
partout
dans
le
corps
de
la
fonction
où
une
instruction
est
acceptée.


–
L’expression
expr
est
de
type
type_res
et
sa
valeur
sera
le
résultat
de
la
fonction.


–
Si
type_res
est
égal
à
void,
l’expression
expr
est
vide
et
la
fonction
est
quittée
par
l’instruction

return
;
ou
à
la
fin
des
instructions.




TABLEAUX



Déclaration
d’un
tableau
à
une
dimension


type_element
nom_du_tableau[nombre_elements];




Déclaration
d’un
tableau
à
une
dimension
avec
initialisation


type
nom_du_tableau[N]
=
{const_1,const_2,...,const_N};




Expression
d’accès
à
un
élément
d’un
tableau
à
une
dimension


nom_du_tableau[indice]




Déclaration
d’un
tableau
à
n
dimensions


type_champ
nom_var[N_dim1][N_dim2]...[N_dimn];




Expression
d’accès
à
un
élément
d’un
tableau
à
n
dimensions


nom_du_tableau[i1][i2]...[in]




Déclaration
d’un
tableau
à
2
dimensions
avec
initialisation


type
nom_du_tableau[M][N]
=
{


{c_0_0,
c_0_1,
...,
c_0_(N‐1)},


...,


{c_(M‐1)_0,
c_(M‐1)_1,
...,
c_(M‐1)_(N‐1)}


};




POINTEURS



Opérateurs


–
&x
retourne
un
pointeur
de
type
type_var
*
vers
la
zone
mémoire
identifiée
par
la
variable
x
de

type
type_var
:


type_var
x;


type_var
*p=&x;


–
*p
retourne
la
valeur
de
la
zone
mémoire
référencée
par
le
pointeur
p
:


type_var
y=*p;




Tableaux
et
pointeurs


Une
variable
de
type
tableau
est
un
pointeur
constant
sur
une
zone
mémoire
continue.


Ainsi,
l’expression
:

–
tab
est

équivalente
à
&(tab[0])


–
tab+i
est
équivalente
à
&(tab[i])


–
tab[i]
est
équivalente
à
*(tab+i)






 Annexe 2
LES
CHAÎNES
DE
CARACTÈRES






A/
Définition


Rappelons
 qu’en
 C
 une
 chaîne
 de
 caractères
 est
 un
 tableau
 unidimensionnel
 de
 caractères
 dont
 le

dernier
 caractère
 significatif
 est
 le
 caractère
 ‘\0’.
 Ainsi,
 la
 constante
 de
 type
 chaîne
 de
 caractères

"bonjour",
est
représentée
en
machine
par
le
tableau
unidimensionnel
de
caractères
ci‐dessous
:


"bonjour" ⇔ 'b' 'o' 'n' 'j' 'o' 'u' 'r' '\0'



Une
variable
de
type
chaîne
de
caractères
peut
être
déclarée
et
initialisée
comme
suit
:


char chaine[10] = "bonjour" ;



ce
qui
signifie
que
la
variable
chaine
est
un
tableau
contenant
10
cellules
de
type
char.




En
mémoire
centrale,
on
a
alors
:



chaine 0 1 2 3 4 5 6 7 8 9
'b' 'o' 'n' 'j' 'o' 'u' 'r' '\0' ? ?


Comme
chaine
est
un
identificateur
de
tableau,
il
s’agit
d’une
constante
de
type
pointeur.


La
 valeur
 de
 chaine
 (*chaine)
 est
 l’adresse
 de
 la
 première
 cellule
 du
 tableau
:

chaine[0].
Ainsi
 pour
 accéder
 à
 une
 cellule
 indicée
 par
 i
 (i<10)
 dans
 le
 tableau
 on
 peut

indifféremment
écrire
:
chaine[i] 
ou

*(chaine+i).

On
 peut
 aussi
 utiliser
 une
 variable
 de
 type
 pointeur
 sur
 un
 caractère
 pour
 déclarer
 et
 initialiser
 une

variable
de
type
chaîne
de
caractères
:


char *Pchaine = "bonjour" ;

Le
 pointeur
 Pchaine
 pointe
 vers
 le
 caractère
 b
 de
 la
 chaîne
 constante
 "bonjour",
 mais
 on
 peut

l’utiliser
comme
s’il
s’agissait
d’un
identificateur
de
tableau
de
caractères,
par
exemple,
pour
imprimer

la
chaîne
avec
:


printf("chaine Pchaine : %s\n", Pchaine) ;

La
procédure
printf
imprimera
tous
les
caractères
qui
suivent,

jusqu’à
rencontrer
le
caractère
‘\0’
;


En
mémoire
centrale,
on
aurait
par
exemple:


Pchaine 0 1 2 3 4 5 6 7
1230 'b' 'o' 'n' 'j' 'o' 'u' 'r' '\0'
Adresses 1230 1234 1238 1242 1246 1250 1254 1258


chaine
et
*Pchaine
ont
toutes
deux
à
ce
moment
pour
valeur
la
chaîne
de
caractères

bonjour.
Mais,
chaine
est
un
tableau
implanté
à
une
adresse
fixe
(ici
1230),
et,
pour

changer
sa
valeur,
il
faut
changer
la
valeur
de
ses
cellules
une
à
une,
alors
que
Pchaine
est
une
variable
pointeur
initialisée
de
façon
à
pointer
initialement
sur
la
même
valeur,

mais
sa
valeur
peut
changer.

Par
exemple,
on
peut
écrire
:

 Pchaine = "salut" ;

Pchaine pointe
maintenant
sur
une
nouvelle
constante
(allouée
quelque
part
ailleurs
en

mémoire)
sans
qu’aucune
recopie
de
caractères
n’ait
été
effectuée.




Ainsi
on
ne
peut
pas
écrire
:


char chaine[10] ;
chaine = "bonjour" ;

Alors
que
l’on
peut
écrire
:

char *Pchaine ;
Pchaine = "bonjour" ;


En
effet,
lors
d’une
affectation,
on
distingue
clairement
la
partie
gauche
du
signe
de

l’affectation
(souvent
notée
en
anglais
lvalue,
pour
left
value)
et
sa
partie
droite.
La
partie

droite
doit
contenir
une
expression
évaluable,
et
la
partie
gauche
une
valeur
modifiable

par
cette
expression.
Une
valeur
modifiable
est
une
variable
dont
le
type
doit
être
défini

(et
l’expression
figurant
en
partie
droite
devra
avoir
un
type
compatible)
et
ne
peut
être
de

type
tableau
ou
fonction.
(Il
ne
peut
s’agir
non
plus
de
type
const,
et
lorsqu’il
s’agira

d’une
structure,
aucun
des
membres
ou
sous‐membres
ne
pourra
être
constant.)



B/
Fonctions
de
la
bibliothèque
string.h


Pour
utiliser
une
fonction
prédéfinie
permettant
de
manipuler
des
chaînes
de
caractères,
il
faut
inclure

le
fichier
d’entête
<string.h>.
Dans
ce
fichier
on
trouve
de
nombreuses
fonctions
intéressantes.


‐
 La
 fonction
 permettant
 de
 calculer
 la
 longueur
 d’une
 chaîne
 de
 caractères
 (à
 savoir
 le
 nombre
 de

caractères
 significatifs
 –
 i.e.
 ceux
 qui
 précèdent
 le
 caractère
 ‘\0’)
 s’appelle
 strlen
 et
 a
 pour

prototype
:


int strlen(<chaine>) ;


où
<chaine>
est
:
soit
une
constante
de
type
chaîne
de
caractères,
soit
un
identificateur

de
tableau
de
caractères,
soit
une
variable
de
type
pointeur
sur
un
caractère.

Exemple
int longueur ;
longueur = strlen("bonjour") ;
/* longueur vaut alors 7 */



‐
La
fonction
prédéfinie
permettant
de
copier
une
chaîne
de
caractères
(appelée
<chaine source>)

dans
une
autre
(ou
à
une
adresse
donnée)
est
strcpy :


char *strcpy(<chaine résultat>, <chaine source>) ;

<chaine résultat>
est
soit
l’identificateur
d’un
tableau
de
caractères,
soit
l’identificateur
d’une

variable
de
type
pointeur
sur
un
caractère.
<chaine source>
est
soit
une
constante
de
type
chaîne

de
 caractères,
 soit
 l’identificateur
 d’une
 variable
 de
 type
 tableau
 de
 caractères,
 soit
 une
 variable
 de

type
pointeur
sur
un
caractère
à
laquelle
est
appliqué
l’opérateur
d’indirection.



Cette
fonction
renvoie
une
valeur
de
type
pointeur
sur
un
caractère.
Cette
valeur
est
l’adresse
du
début

de
la
chaîne
recopiée
(c’est‐à‐dire
la
valeur
du
premier
paramètre
formel).

 Exemple
char c[100]= "bonjour" ;
/* pour afficher la chaîne «programmation» et la stocker
dans la variable c */
printf(«%s», strcpy(c, "programmation") );

0 1 2 3 4 12 13 14 ...
c 'b' 'o' 'n' 'j' 'o' …

"programmation" 'p' 'r' 'o' 'g' 'r' … 'n' '\0'

Remarque
:
 Attention,
 cette
 fonction
 recopie
 tous
 les
 caractères
 de
 la
 chaine
 source
 dans
 la
 chaîne

résultat,
mais
elle
suppose
que
la
chaîne
résultat
contient
suffisamment
de
place
pour
que
la
recopie

soit
possible.
Tout
se
passera
donc
bien
si
on
a
déclaré
par
exemple


char tab[80];
char *ret ; /* ou char ret[] ; */
ret = strcpy(tab, "programmation") ;
Mais,
le
programme
sortira
en
erreur
avec
:



ret = strcpy(ret, "programmation") ;




‐
 La
 fonction
 prédéfinie
 strcat
 permettant
 de
 concaténer
 deux
 chaînes
 de
 caractères
 a
 pour

prototype
:


char *strcat(<chaine resultat>, <chaine source>) ;



Cette
fonction
concatène
la
chaine
résultat
et
la
chaine
source
et
retourne
la
chaine

source
:
elle
recherche
la
fin
de
la
chaîne
ayant
pour
adresse
la
valeur
du
premier

paramètre
formel,
puis
effectue
la
recopie
de
la
chaine
source
à
cette
adresse
et
retourne
le

premier
paramètre
formel.

Exemple
char *pc = " impérative";
/* pour concaténer la chaîne de caractères stockée dans c
avec celle pointée par la variable pc
et afficher le contenu de c */
printf("‰s", strcat(c, pc)) ;
Remarque
:
 Attention,
 ici
 aussi,
 la
 fonction
 suppose
 qu’il
 y
 a
 assez
 de
 place
 disponible
 dans
 la
 chaîne

résultat
(ici
c)
pour
y
recopier
à
la
fin
le
contenu
de
la
chaîne
source.


‐
La
fonction
prédéfinie
permettant
de
comparer
deux
chaînes
de
caractères
a
pour
prototype
:


int strcmp(char *chaine1, char *chaine2) ;



Le
résultat
de
l’exécution
de


strcmp (<chaine1>,<chaine2>)
est
:


• inférieur
à
0
si
<chaine1>
est
inférieure
à
<chaine2>
selon
l’ordre
lexicographique,


• égal
à
0
si
<chaine1>
et
<chaine2>
sont
identiques,


• supérieur
à
0
si
<chaine1>
est
supérieure
à
<chaine2>
selon
l’ordre
lexicographique.

 Exemple
char chaine[10]= "bonjour";
char *c1,*c2 ;

c1 = chaine ;
c2 = chaine ;
Dans ce cas c1==c2 vaut vrai et strcmp(c1,c2) vaut 0.
c1



 
 bonjour


c2


‐
La
fonction
prédéfinie
permettant
de
copier
une
suite
de
caractères
d’une
chaîne
à
partir
d’une
autre

chaîne
de
caractères
a
pour
prototype
:


void *memmove(char *s1, const char *s2, int n)



Elle
copie
à
partir
de
l’adresse
s1,
la
suite
des
n
caractères
qui
débute
à
l’adresse
s2.

Elle
retourne
s1
(de
type
pointeur
générique
void
*).


Cette
fonction
est
très
utile
pour
supprimer
ou
insérer
une
suite
de
caractères
dans
une

chaîne
de
caractères.



C/
Fonctions
de
la
bibliothèque
de
manipulation
de
caractères

Le fichier d'en-tête <ctype.h> contient les déclarations des fonctions qui testent et qui convertissent
les caractères. Chaque paramètre de type int peut être un unsigned char ou la constante prédéfinie
EOF. Voici quelques-unes de ces fonctions.

Prototype Description

int isalpha(int c) retourne une valeur non nulle si c est une lettre

int isupper(int c) retourne une valeur non nulle si c est une lettre majuscule

int islower(int c) retourne une valeur non nulle si c est une lettre minuscule

int isdigit(int c) retourne une valeur non nulle si c est un chiffre

int isspace(int c) retourne une valeur non nulle si c est un caractère d’espacement
(espace, tabulation, retour de chariot)

int toupper(int c) retourne c converti en majuscule

int tolower(int c) retourne c converti en minuscule

D/
Autres
fonctions
de
traitement
de
chaînes
de
caractères


Le fichier d'en-tête <string.h> contient, entre autres, les déclarations des fonctions qui manipulent
les chaînes de caractères. Dans le tableau qui suit, les paramètres nommés s sont de type char*, les
paramètres nommés cs, cs1 et cs2 sont de type const char*, les paramètres nommés n sont de
type size_t et les paramètres nommés c sont de type int converti en char. Voici quelques-unes des
fonctions disponibles dans ce fichier d'en-tête.
Prototype Description

char* strcpy(s, cs) copie la chaîne cs, y compris '\0', dans la chaîne s;
retourne s.

char* strncpy(s, cs, n) copie au plus n caractères de la chaîne cs dans s;

retourne s. Complète par des '\0' si cs comporte moins
de n caractères.

char* strcat(s, cs) concatène la chaîne cs à la suite de la chaîne s; retourne

s.

char* strncat(s, cs, n) concatène au plus n caractères de la chaîne cs à la chaîne

s, termine s par '\0'; retourne s.

int strcmp(cs1, cs2) compare la chaîne cs1 à la chaîne cs2; retourne une
valeur négative si cs1 < cs2, nulle si cs1 == cs2,
positive si cs1 > cs2.

int strncmp(cs1, cs2, n) compare au plus n caractères de la chaîne cs1 à la chaîne

cs2; retourne une valeur négative si cs1 < cs2, nulle
si cs1 == cs2, positive si cs1 > cs2.

char* strchr(cs, c) retourne un pointeur sur la première occurrence de c dans

cs, ou NULL s'il n'y a pas d'occurrences.

char* strrchr(cs, c) retourne un pointeur sur la dernière occurrence de c dans

cs, ou NULL s'il n'y a pas d'occurrences.

char* strstr(cs1, cs2) retourne un pointeur sur la première occurrence de la

chaîne cs2 dans la chaîne cs1, ou NULL s'il n'y a pas
d'occurrences.

size_t strlen(cs) retourne la longueur de la chaîne cs.

E/
Fonctions
de
conversion
de
chaînes
de
caractères

Le fichier d'en-tête <stdlib.h> contient, entre autres, les déclarations des fonctions qui convertissent
les chaînes de caractères. Voici quelques-unes des fonctions disponibles dans ce fichier d'en-tête.

Prototype Description

int atoi(const char* s) convertit s en int; retourne la conversion.

long atoll(const char* s) convertit s en long; retourne la conversion.

double atof(const char* s) convertit s en double; retourne la conversion.





 Annexe 3

Traitement des Fichiers

I. Introduction

Un fichier est un ensemble d’informations structurées selon un format bien déterminé

et stockées sur une mémoire auxiliaire.
Les opérations permises sur les fichiers textes sont :

∫ Ouverture d’un fichier.

∫ Lecture à partir d’un fichier.
∫ Écriture dans un fichier.
∫ Déplacement dans un fichier.
∫ Fermeture d’un fichier.

II. Ouverture d’un fichier

La primitive fopen( ) permet d’ouvrir le fichier spécifier en argument.

Syntaxe :
FILE * < descripteur de fichier > ; /* déclaration d’une variable de type FILE */
< descripteur de fichier > = fopen( <nom_fichier>, <mode>) ;
< descripteur de fichier > : chaîne de caractères ;
< nom_fichier > : chaîne de caractères <= 8;
<mode> :{ r, w, r+, w+, a, a+} où
r : Ce mode permet d’ouvrir le fichier seulement pour la lecture. Si le fichier n’existe pas,
la fonction fopen( ) renvoie la constante NULL.

w : Ce mode permet d’ouvrir le fichier pour l’écriture, si le fichier existe déjà, son contenu
sera détruit.

r+ : Ouverture du fichier pour la lecture et l’écriture, le fichier doit exister.

w+ : Ouverture du fichier l’écriture et la lecture, si le fichier existe déjà son contenu sera
détruit.

a : Ouverture du fichier pour l’écriture à la fin.

a+ : Ouverture du fichier pour la lecture et l’écriture à la fin.

III. Lecture à partir d’un fichier

La fonction fgetc(<descripteur de fichier>) renvoie le caractère lu à partir de la

position courante du descripteur. La valeur EOF indique la fin de fichier.
Exemple :
FILE * fp ; /* déclaration d’une variable fp de type FILE */
int i =0;
char c ;
fp=fopen(″c:\test.txt″, ″r″) ; /*ouverture de fichier test.txt en mode lecture */
while( ( c=fgetc( fp) ) != EOF ) /* lecture caractère par caractère */
i++ ; /* traitement sur le contenu du fichier */

La fonction fgets(s, n, <descripteur>) effectue une lecture du fichier spécifié par son
descripteur et stocke les caractères lus dans la chaîne s. la lecture contenue jusqu’à ce que
l’un des caractères ‘\n’ ou EOF soit détecté ou que le nombre de caractères lus égale à n-
1. Le caractère ‘\0’ est ajouté automatiquement à la fin de la chaîne s.

IV. Écriture dans un fichier

La fonction fputc(c, <descripteur de fichier>) permet d’écrire le caractère c à la

position courante du descripteur de fichier. Cette primitive renvoie –1 si une erreur
d’écriture est détectée.

La fonction fprintf(<descripteur de fichier>, <contrôle>, <argument>) permet

d’écrire dans un fichier spécifié par son descripteur le contenu des arguments et ce en ce
basant sur les champs de contrôle.

Exemple1 :( lecture caractère par caractère à partir d’un fichier fich1 et écriture dans un
autre fich2):

FILE * fp1, *fp2 ;

int i =0;
char c ;
fp1=fopen(″fich1″, ″r″); /*ouverture du premier fichier fich1en mode lecture*/
fp2=fopen(″fich2″, ″w″); /*ouverture du fichier fich2 en mode écriture */
if( (fp1==NULL) ||(fp1==NULL) )
return ;
while( ( c=fgetc(fp1 ) ) != EOF ) /*lecture caractère par caractère du fich1*/
{
fputc(c, fp2) ; /* écriture dans fich2 */
i++ ;
}
fprintf(fp2, ″le nombre de caractères écrit est %d ″, i) ;

Exemple2 :( lecture à partir du clavier de toute une ligne et écriture dans un fichier):

FILE * fp1 ;
char *chaine ;
fp1=fopen(″fich1″, ″w″);
if( (fp1==NULL) ) return ;
 gets(chaine ) ;
fprintf(fp1, ″ %s ″, chaine ) ;
Exemple1 :( lecture d’un ensemble de lignes à partir d’un fichier fich1 et écriture dans un
autre fich2):

FILE * fp1, *fp2 ;

char *chaine ;

fp1=fopen(″fich1″, ″r″);
fp2=fopen(″fich2″, ″w″);
if( (fp1==NULL) ||(fp1==NULL) )
return ;
while( fgets(chaine, 80, fp1))
fprintf(fp2, ″ %s ″, chaine ) ;

V. Déplacement dans un fichier

La fonction fseek(<descripteur de fichier>, <offset>, <origine>) pointe la position

courante du fichier décrit par son descripteur sur la position offset calculée à partir du
paramètre origine.

<descripteur> : c’est le descripteur de fichier ;

<offset> : déplacement à effectuer en nombre d’octets ;
<origine> : la position à partir de laquelle un déplacement de offset octets sera effectué.
Elle est égale à l’une des constantes suivantes.

SEEK-SET : début de fichier ;

SEEK-CUR : position courante ;
SEEK-END : fin de fichier.

Exemples :
∫ fseek(fp, 25L, SEEK-SET) : déplacement de 25 octets à partir de début du fichier.
∫ fseek(fp, -100L, SEEK-END) : déplacement de 100 octets vers l’arrière à partir de la fin
du fichier.

VI. Quelques fonctions standards

∫ La fonction fclose(<descripteur de fichier>) permet de fermer le fichier dont le

descripteur est donné en argument.

∫ La fonction ftell(<descripteur de fichier>) renvoie l’offset de la position courante

du descripteur par rapport au début de fichier.

∫ La fonction rewind(<descripteur de fichier>) permet de retourner le descripteur

vers le début de fichier.
Exercice :
Écrire un programme C qui rempli dans un fichier une liste de caractères acceptés à partir
du clavier.
- Le caractère ‘#’ détecte la fin de la liste de caractères.
- Le nom de fichier doit être accepté à partir du clavier.

main( )
{
char nom[ 10 ] ;
FILE *fp ;
printf(″ Entrer le nom du fichier : ″) ;
scanf(″%s″,nom) ;
fp=fopen(nom, ″w″) ;
if(fp==NULL)
return ;
printf(″ \n Entrer la liste de caractères, # pour terminer ″) ;
while( ( c=getchar( ) ) != ‘#’)
fputc(c, fp) ;
fclose(fp) ;
printf(″ \n Chargement terminé ″) ;
}
 Annexe 4

Traitement des structures

I. Présentation générale

Une structure (ou enregistrement ) est une collection de variables regroupées sous un
nom unique pour une utilisation plus simple.

Syntaxe :
struct nom_structure
{
liste de déclaration des champs ;
}

∫ La déclaration des variables de type structure se fait comme suit :

struct nom_structure nom_variable_1 ; nom_variable_2, ….etc.

∫ L’accès à un champ de l’enregistrement se fait toujours en spécifiant le nom de la

variable suivi par ‘.’ (point) suivi par le nom du champ.
Exemple :
struct étudiant
{
int cin ;
int âge ;
char section[ 10 ] ;
}

∫ Déclaration d’une variable e1 de type étudiant : struct étudiant e1 ;

∫ Initialisation du champ âge de e1 : e1.âge=20 ;
∫ Copie la section de e1 dans une variable s de type chaîne de caractères :
strcpy(s, e1.section).

Remarque :
Les membres d’une structure peuvent être eux même des structures.
(Exemple un champ date_naiss peut être une structure de jour, mois et
année dans l’enregistrement étudiant).

II. Tableau de structure

Un tableau de structures est un tableau dont les éléments ont pour type une
structure définit précédemment.
Exemple :
On considère la structure étudiant déjà déclarée.

∫ La déclaration d’un tableau e de douze étudiants se fait par l’instruction

struct étudiant e[12] ;

∫ L’initialisation du champ âge de tous les étudiants se fait par l’instruction

for(i = 0 ; i<12 ; e[ i ].âge = 20 ; i++) ;

∫ L’initialisation de tous les champs du tableau e se fait comme suit :

e[ 12 ]={ {1, 20, ″INFO2GES″},
{2, 20, ″INFO2GES″},
…
{12, 20, ″INFO2GES″} } ;

III. Définition d’un type pour une structure

La déclaration typedef struct nom_structure permet de créer un nouveau type

dont le nom est nom_structure.
Exemple :
typedef struct étudiant
{
int cin ;
int âge ;
char section[ 10 ] ;
};
Au niveau du programme, on peut déclarer des variables de type étudiant sans
spécifier le terme struct.

Exemple :
main( )
{
int i ;
étudiant e[12] ; /* sans spécifier le terme struct */
for(i=0 ; i<12 ; e[ i ].âge=20,i++) ;
}

IV. Taille d’une structure

La fonction sizeof(e1) renvoie la taille de la structure e1 en octets. La taille

globale de la structure est calculée tout en effectuant la somme des tailles de
différents membres de la structure.

Exemple :
struct étudiant
{
int cin ; /* réservation de 2 octets */
 int âge ; /* réservation de 2 octets */
char section[ 10 ] ; /* réservation de 10 octets */
} e1;
sizeof(e1)=14.
Remarque :
La fonction memcpy(&e1, &e2, sizeof(e1) ) permet de copier tout la
structure e2 dans e1.

Exercice :
Écrire un programme C qui calcule et affiche la moyenne d’une classe de 12 étudiants.
Chaque étudiant est identifié par un numéro de carte d’identité (cin), un nom, prénom
et une liste de 10 matières et une moyenne calculable (moy_et). On suppose que les dix
matières ont le même coefficient.

Correction :
typedef struct étudiant
{
int cin ;
char nom[10], prénom[10] ;
int note_mat[10] ;
float moy_et ;
};
main( )
{
étudiant e[12] ;
int i ;
float somme = 0.0 ;
for( i=0 ; i<12 ; i++)
e[ i ]. moy_et = calcul_moy( e, i );
for( i=0 ; i<12 ; i++)
somme = somme + e[ i ]. moy_et ;
printf(″ La moyenne générale de la classe est %f″, somme/12) ;
}

/* développement de la fonction calcul_moy */

calcul_moy(e, i )
étudiant e[12] ;
int i ;
{
int j ;
float somme=0.0 ;
for(j=0 ; j<10 ; j++)
somme = somme + e[ i ]. note_mat ;
return(somme/10) ;
}
 V. Structures et pointeurs

L’écriture struct nom_structure *ptr ; permet de décaler une variable ptr de

type pointeur sur une structure. L’opérateur -> (signe moins suivi du signe
supérieur) permet d’accéder aux différents membres de la structure.

Exemple :
struct étudiant *e ;
int a ;
a = e -> âge /* affecter le contenu du champ âge dans la variable a */

V.1 Allocation de la mémoire

Il existe deux modes d’allocation de la mémoire :

⊇ Allocation statique : C’est le fait d’allouer un espace mémoire lors de la déclaration

d’une variable.

Exemple :
int a ; /* réservation de 2 octets mémoire */
char tab[ 100 ] ; /* réservation de 100 octets */

Ce type d’allocation présente deux inconvénients à savoir :

* La réservation d’un espace mémoire pour une variable reste tout au long
de l’exécution du programme, même si cette variable est inutilisable.

* Risque de gaspillage de la mémoire dans le cas de déclaration d’un tableau

long et le traitement se fait seulement sur une partie de ce tableau.
Comme solution à ces inconvénients, on adopte l’allocation dynamique.

* Allocation dynamique : c’est une allocation de la mémoire pour un besoin

courant de traitement et possibilité de libération dès que le traitement prend
fin.
L’allocation dynamique se fait par :

<variable> = (type de variable * ) malloc( sizeof( type de la variable)) ; la fonction

malloc( ) retourne dans variable l’adresse de l’espace allouer ou NULL en
cas de problème d’allocation.

Exemple :
e= (struct étudiant * ) malloc( sizeof(struct étudiant)) ; /* allocation d’un espace
mémoire de type étudiant pointé par e */

La primitive free( < variable> ) permet de libérer la mémoire.




V.2 Les listes chaînées

C’est en fait une liste de cellules mémoires (ou nœuds ) reliées par une référence
(ou adresse). Chaque cellule est une structure dont les membres en plus des valeurs
on trouve des pointeurs vers la cellule suivante et/ou la précédente.
Exemple :
struct étudiant
{ int cin ;
int âge ;
char section ;
struct étudiant *next ;
};

Suite à l’appel à l’instruction

nœud=(struct étudiant *) ( malloc(sizeof(struct étudiant) ), une cellule
de la forme
cin âge section next

prend place en mémoire. L’exécution de la dernière instruction plusieurs

fois, accompagné d’un traitement de liens entre les nœuds crées produisent
la liste suivante :

cin âge section next cin âge section next

nœud_1 nœud_2

Exemple :
# include<stdio.h>
# include<string.h>
# include<alloc.h>
main( )
{
struct étudiant *first, *p, préced ;
int num ;
first = préced = NULL ;
printf(″entrer le numéro de la CIN de l’étudiant, -1 pour terminer″) ;
scanf(″%d″,&num) ;
while(num != -1)
{
p=(struct étudiant * ) malloc( sizeof(struct étudiant)) ;
p->cin=num ;
scanf(″%d″,&p->âge) ;
scanf(″%s″,&p->section) ;
if(first == NULL)
first=p ;
else



préced -> next = p ;

préced = p ;
scanf(″%d″,&num) ;
}
traitement(first) ; /* appel à fonction de traitement de la liste de données */
libérer(first) ; /* appel à fonction de libération de l’espace mémoire */
}

/* développement de la fonction de libération de la mémoire */

libérer(first)
struct étudiant *first ;
{
struct étudiant *first ;
while(first)
{
p = first -> next ;
free( first ) ;
first = p ;
}
}