Cours de C

Dpartement Gnie Civil & Dpartement Mcanique nergtique
Programmation Structure
Langage C
Laurence.Bergougnoux@univ-amu.fr
http://iusti.polytech.univ-mrs.fr/~bergougnoux/
UE :
Mathmatiques & Informatique
En GC UE 52
ce sera le seul cours du cursus ...
En ME UE 53
+ UE 63 Calcul scientifique et
langage Fortran avec Jacques Massoni au
semestre 6
Commun avec MT et GII Rmy Bulot
Progr. struct. - C
Introduction
L'quipe enseignante
Laurence BERGOUGNOUX
Franois GUILLARD
Christian MARIANI
Fabien PETITPAS
Jrme VICENTE
Bureau 208
Bureau 242
Bureau 321
Bureau 319B
Bureau 326
Prenom.Nom@polytech.univ-mrs.fr
ou
Prenom.Nom@univ-amu.fr
Avec la participation de Jean-Luc FIRPO
Progr. struct. - C
Introduction
Organisation de l'enseignement
ME
GC
14h cours
14h TD
20h TP
14h cours
20h TD
20h TP
La semaine 51
Mini projet & oral

+
Contrle continu
+
Examen ME
Progr. struct. - C
Projet & oral

+
Contrle continu
+
Examen GC
Introduction
Maxime Alarcon
&
Yassine El Khatari
Organisation de l'enseignement
Transparents de cours en fichier pdf sur :
- le Bureau virtuel
- http://iusti.polytech.univ-mrs.fr/~bergougnoux/enseignement.htm
1er TP sur machine la semaine prochaine :
Accs avec votre n tudiant et code INE
Si vous n'tes pas encore inscrit :
- en ME prendre contact avec M. Daurelle (bur. 326)
- en GC avec M. Court ou M. Thuilliez (bur. 237)
Progr. struct. - C
Introduction
En pratique : le 1er TD c'est

GC 3.1, Mercredi 09/10, 15h30
GC 3.2, Mercredi 09/10, 13h30
ME
ME
ME
ME
3.1, Lundi 07/10, 10h

3.2, Lundi 07/10, 13h30
3.3, Vendredi 11/10, 10h
3.4, Mardi 08/10, 13h30
Progr. struct. - C
Introduction
Plan du cours
1.
2.
3.
4.
5.
6.
7.
8.
9.
Introduction
Les bases du langage C
Les pointeurs et les tableaux
Les fonctions
Les types utilisateurs
La gestion de fichiers
La programmation modulaire
L'allocation dynamique de mmoire
Les listes chanes
Les objectifs de ces cours,

TD, TP
Apprendre rsoudre un problme grce un
algorithme,
Apprendre programmer en C des dbutants de
manire efficace,
Initier la programmation par gestion d'vnements,
Pratiquer un environnement de dveloppement
largement utilis dans l'industrie,
tre une introduction au C++
...
Progr. struct. - C
Introduction
Progr. struct. - C
Introduction
Quelques gnralits
en programmation
Qu'est-ce qu'un Algorithme ?

Langages de Programmation
Qu'est-ce qu'un programme ?
La structure d'un programme
L'excution du programme
Progr. struct. - C
Quelques gnralits
10
Qu'est-ce qu'un Algorithme ?

Un algorithme nonce une rsolution sous la
forme dune srie doprations effectuer.
donnes
(entres)
ingrdients
Progr. struct. - C
Algorithme
Recette de cuisine
Quelques gnralits
rsultat
(sorties)
plat
11
Conception d'un Algorithme :

Analyse hirarchise
C'est faire une liste de tches (ou d'actions)
raliser de manire squentielle.
1)
2)
3)
4)
5)
6)
8)
Recette du gteau la crme de marrons :
Prchauffer le four 180C

Faire fondre le chocolat et le beurre
Casser 3 ufs et les battre
Ajouter la crme de marrons, et mlanger
Incorporer le chocolat fondu la prparation
Beurrer un moule gteau et y verser la prparation
Faire cuire 35 min 180C
Progr. struct. - C
Quelques gnralits
12
Langages de programmation :
Pourquoi faire?
Pour crire avec des mots et signes
comprhensibles par une intelligence humaine
plutt que 00111000111
Afin d'organiser, de structurer, le droulement
d'un programme de manire claire et vrifiable.
Progr. struct. - C
Quelques gnralits
13
Quelques Langages
Par ordre chronologique :
Assembleur 68000, 8086
Fortran, Cobol
Basic, Pascal, Langage C
Langages Objets : C++, Java , C#,
http://www.scriptol.fr/programmation/langages-populaires.php
Progr. struct. - C
Quelques gnralits
14
Programme excutable
Suite dinstructions binaires que le processeur
doit effectuer :
Spcifiques un type de processeur.
Stockes sur une mmoire de masse
(disque dur, DVD, clef usb).
Charges en mmoire centrale avant
lexcution du programme.
Progr. struct. - C
Quelques gnralits
15
Comment raliser un programme ?

diter le code source : fichier texte qui obit aux
rgles de syntaxe du langage.
Le sauvegarder de temps en temps.
Le compiler, le traduire en langage machine pour
obtenir un fichier excutable.
Fichier Compilation
Source
Progr. struct. - C
Fichier
Objet
diteur
de liens
Quelques gnralits
Fichier
Excutable
16
L'excution du programme
Au lancement du programme, le systme
dexploitation :
Transfre le programme de la mmoire de
masse en mmoire centrale,
Rserve de la place pour les donnes du
programme,
Dmarre lexcution du programme,
Reprend la main quand le programme sachve.
Progr. struct. - C
Quelques gnralits
17
1er programme en C
Langage C : histoire et qualits

LabWindows/CVI
Le fichier source en C
On se lance
Progr. struct. - C
1er programme
18
Le langage C
Cre par K. Thompson, D. Ritchie et B. Kernighan
pour dvelopper UNIX.
Cest un langage structur et portable.
Cest le langage le plus utilis par les professionnels
du logiciel.
Cest la base du C++ qui permet la programmation
oriente objet.
Progr. struct. - C
1er programme
19
LabWindowsTM/CVI
Environnement de Dveloppement Intgr (IDE)
sous Windows, avec 1 compilateur C-ANSI.
Programmation vnementielle
et interface graphique.
Logiciels de mesure et contrle
Progr. struct. - C
1er programme
20
Premier Programme
en langage C
sous LabWindows/CVI
source_1.c
Progr. struct. - C
1er programme
21
Le fichier Source en C
source_1.c
#include <stdio.h> // fichier en-tte ou header o
se trouve la dfinition de printf()
int main()
//Fonction ou bloc principal
{
printf("Bienvenue a POLYTECH Marseille \n");
return(0);
}
Progr. struct. - C
1er programme
22
Les bases du langage C

1.
2.
3.
4.
Les
Les
Les
Les
Prog. Struct. - C
types de donnes
variables
oprateurs
structures conditionnelles
Les bases
23
Types, variables et constantes

Qu'est-ce qu'une variable ?
c'est le nom dun emplacement mmoire
0001110000110000
on en cre presque autant quon veut
son contenu peut changer dans le temps.
elle contient toujours quelque chose !!!
Une variable sera toujours dfinie avant utilisation :

elle doit tre associe un type de donnes.
Prog. Struct. - C
1. Les types de donnes
24
Les types de donnes

Qu'est-ce qu'un type ?
dfinit une convention de codage de l'information

dans un emplacement de taille prfixe
1 nombre : entier ou rel

1 Variable en C
1 pointeur : adresse
Prog. Struct. - C
25
Les nombres entiers

Types
prdfinis
Signification
Taille (octet)
Plage de valeurs
char
Caractre
-128 127
unsigned char
Caractre non
sign
0 255
short int
Entier court
-32 768 32 767
unsigned short
int
Entier court non

sign
0 65 535
int
Entier
-2 147 483 648

2 147 483 647
unsigned int
Entier non sign
0 4 294 967 295
long int
Entier long
-2 147 483 648

2 147 483 647
unsigned long
int
Ent. long non

sign
0 4 294 967 295
Prog. Struct. - C
26
Les nombres rels

Types
prdfinis
float
double
long double
Prog. Struct. - C
Signification
Taille (octet)
Rel simple prcision 4

Rel double
prcision
Flottant double
long
Plage de valeurs
3,4 x 10-38 3,4 x 1038
1,7 10-308 1,7 10308
10
3,4 10-4932 3,4 104932
27
Codage binaire
des nombres entiers
1970=1024 + 512 + 256 + 128 + 32 + 16 + 2
= 210
+ 29 + 28 + 27 + 25 + 24 + 21
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
00 00 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1110110010
des nombres rels

197,75 = 128 + 64 + 4 + 1 , 0.5 + 0.25
= 27 + 26+ 22 +20, 2-1 + 2-2
= 11000101,11
signe
= 1,100010111 x 27
exposant = 7+127=134=1000 0110
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
0 1 00 0 0 11 0 1 0 0 0 1 0 1 1 1 0 0 0 0 0000000000
exposant
mantisse
Prog. Struct. - C
28
Les pointeurs
Type
*pointeur
Signification
adresse
Prog. Struct. - C
Taille (octet)
Plage de valeurs
2 (sur 16 bits)
0x0000 0xFFFF
4 (sur 32 bits)
0x00000000 0xFFFFFFFF
29
Leur nom :
Les variables
Contient 32 caractres max

Commence par une lettre
Ne peut tre un des mots rservs du C
auto
default
float
register struct
volatile
break
do
for
return
switch
while
case
double
goto
short
typedef
char
else
if
signed
union
const
enum
int
sizeof
unsigned
long
static
void
continue extern
Prog. Struct. - C
2. Les variables
30
Les variables : leurs noms

identificateur
Correct
incorrect
Raison
Variable
Nom de Variable
comporte des espaces
Nom_De_Variable
123Nom_De_Variable
nom_de_variable
toto@mailcity.com
nom_de_variable_123
Nom-de-variable
_707
goto
MAJUSCULE
Prog. Struct. - C
commence par un
chiffre
caractre spcial @
signe - interdit
nom rserv
minuscule
2. Les variables
31
La dclaration de variables
type nom_de_la_variable ;
exemple :
#include <stdio.h>
int main()
{
int a;
//dclaration
char var_car = 'f'; // + initialisation
char *pointe_ici;
// le pointeur
a = 127;
//affectation
pointe_ici = &var_car;
printf("la valeur de a = %i",a);
//affichage
printf("\n et celle de var_car %c", var_car);
}
Prog. Struct. - C
2. Les variables
32
Les constantes
#include <stdio.h>
//Directive du pr processeur
#define PI 3.14159
int main()
{ float a;
//Dclaration d'une constante
const int douze=12;
a = douze*PI;
}
Prog. Struct. - C
2. Les variables
33
Ce que vous allez faire le + souvent :

Afficher l'cran une variable
int Nb_vies=3;
printf("Pour afficher l\' cran\n");
printf("il vous reste %d vies",Nb_vies);
Saisir au clavier le contenu d'une variable
int age;
printf("Entrez votre age :");
scanf("%d",&age);
char %c
int
Prog. Struct. - C
%d
float
%f
double %lf
2. Les variables
34
Les oprateurs du C
les oprateurs de calcul

d'assignation
d'incrmentation
de comparaison
logiques
bit--bit
de dcalage de bit
Les priorits
Prog. Struct. - C
3. Les oprateurs
35
Les oprateurs de calcul

Oprateur
Exemple
Si
Si
int x=10;
float x=10.0;
d'addition
x=x+3;
13
13.0
de soustraction
x=x-3;
7.0
de multiplication
x=x*3;
30
30.0
de division
x=x/3;
3.3333333
modulo
x=x%3;
x=3;
Met la valeur 3
dans la variable x
d'affectation
reste de la division
Met la valeur 3.00

dans la variable x
=
Prog. Struct. - C
3. Les oprateurs
36
Les oprateurs d'assignations

x=x+2;
peut aussi s'crire x+=2;
+=
additionne deux valeurs et stocke le rsultat dans la

variable ( gauche) x
-=
soustrait deux valeurs et stocke le rsultat dans la variable
*=
multiplie deux valeurs et stocke le rsultat dans la variable
/=
divise deux valeurs et stocke le rsultat dans la variable
x=a=b=3;
Prog. Struct. - C
x= (a= (b=3));
3. Les oprateurs
37
Les oprateurs d'incrmentation

ce sont les + utiliss
++ : incrmentation de 1
x=3;
//post-incrmentation
y=x++; y=x; x=x+1; //y=3, x=4
//pr incrmentation
y=++x; x=x+1; y=x; //x=y=5

-- : dcrmentation de 1
y=x--; y=x; x=x-1; //y=5, x=4
Prog. Struct. - C
3. Les oprateurs
38
Les oprateurs de comparaison

utiliss lors de tests
Oprateur
Exemple Rsultat si x vaut 7
==
galit
x==3
Retourne 1 si x est gal 3,

sinon 0
<
infriorit stricte
x<3
Retourne 1 si x est infrieur

3, sinon 0
<=
infriorit
x<=3
Retourne 1 si x est infrieur ou

gal 3, sinon 0
>
supriorit
stricte
x>3
Retourne 1 si x est suprieur

3, sinon 0
>=
supriorit
x>=3
Retourne 1 si x est suprieur

ou gal 3, sinon 0
!=
diffrence
x!=3
Retourne 1 si x est diffrent de

3, sinon 0
Prog. Struct. - C
3. Les oprateurs
39
Les oprateurs bit--bit

Oprateur
&
ET
OU
OU exclusif
Prog. Struct. - C
Syntaxe
9 & 12
Rsultat
1001
& 1100
1000
9 | 12
1001
| 1100
1101
13
9 ^ 12
1001
^ 1100
0101
3. Les oprateurs
40
Les oprateurs de dcalage de bit

Oprateur
Syntaxe
Rsultat
6 << 1
<<
00000110 << 1
= 00001100
Dcalage gauche
12
x2
6 >> 1
>>
Dcalage droite avec

conservation du signe
00000110 >> 1
= 00000011
/2
En sign : -6 <<1 = -12

Prog. Struct. - C
-6 >>1 = -3
3. Les oprateurs
11111010 << 1
= 11110100
11111010 >> 1
= 11111101
41
Les priorits
+++
()
-*
+
<<
<
==
&
^
|
&&
?:
=
[]
++ ! ~ / %
>>
<= >= >
!=
||
+=
-=
etc.
--Prog. Struct. - C
3. Les oprateurs
42
4 types d'instructions
Nulle ;
Expression a=b+1;
Prdfinie condition ou boucle if ()
Bloc { }
Prog. Struct. - C
4. Les structures conditionnelles
43
Les structures conditionnelles

Les instructions de branchement conditionnel
if(condition)
if(condition) else
switch(variable) case
si (vrai) alors
sinon ...
Les instructions de boucle

while(condition)
do while(condition);
for(initialisation;condition;incrementation)
Prog. Struct. - C
44
L'instruction if
syntaxe :
if(condition)
{
instructions;
}
FAUX
condition
VRAI
instructions
Prog. Struct. - C
45
L'instruction if(condition)else
syntaxe :
if(condition)
{
instructions;
}
else
{
instructions;
}
Prog. Struct. - C
condition
VRAI
FAUX
instructions
instructions
46
L'instruction ifelse
Exemple :
if (var1==0)
//si var1 vaut 0
{
//alors on affiche
printf("La variable est nulle\n");
}
else
//sinon c'est faux
{
if (var1 > 0)
{ printf("Elle est positive\n");
else
{ printf("Elle est ngative");
}
Prog. Struct. - C
4. Les instructions conditionnelles
}
}
47
Attention aux forts d'if()

exemple :
if (var1!=0)
if (var1 > 0)
printf("Elle est positive\n");
else
printf("Elle est ngative\n");
else se rapporte toujours au if le plus proche
Prog. Struct. - C
48
L'oprateur conditionnel
(condition) ? instruction_vrai : instruct_faux
exemple :
x = 3;
y = 2;
max_xy = ((x>=y) ? x : y);
=
1
Prog. Struct. - C
max_xy = x;
49
Pour faire plusieurs tests la fois : les
oprateurs conditionnels logiques

Oprateur
||
&&
!
OU logique
ET logique
NON logique
Prog. Struct. - C
Syntaxe
((cond1)||(cond2))
((cond1)&&(cond2))
a b
a||b
a&&b
!a
0 0
0 1
1 0
1 1
(!condition)
3. Les oprateurs
50
L'instruction de choix multiples :

switch
Syntaxe :
switch (expr)
{ case const1:
instructions;
break;
case const2:
instructions;
break;
default:
instructions;
break;
}
Prog. Struct. - C
?
==const1
V
instr.
?
==const2
V
instr.
?
!=const1,2
V
instr.
51
exemple :
switch
char choix;
printf("Taper 1 ou 2");
scanf("%c",&choix);
switch(choix)
{
case '1':
printf("vous avez tape 1\n");
break;
case '2':
printf("vous avez tape 2\n");
break;
default :
printf("je vous ai dit 1 ou 2 pas %c\n",choix);
break;
}
Prog. Struct. - C
52
Les instructions de boucle :
pour rpter les

mmes instructions
plusieurs fois
Prog. Struct. - C
53
L'instruction while
tant que (condition vraie)
syntaxe :
condition
while(condition)
{
instructions;
}
Prog. Struct. - C
FAUX
VRAI
instructions
54
L'instruction dowhile
faire tant que (condition vraie)
syntaxe :
do
{
instructions
instructions;
}while(condition);
Prog. Struct. - C
VRAI
condition
FAUX
55
L'instruction for()
initialisation du
compteur de boucle
syntaxe :
for( init;condition;incrment)
{
instructions;
condition
}
VRAI
exemple :
for(i=0;i<100;i++)
{
printf("%d\n",i);
}
Prog. Struct. - C
FAUX
instructions
modification du
compteur de boucle
56
Attention aux boucles sans fin

;
exemple :
for( ; ; )
{
printf("sans fin\n");
}
Prog. Struct. - C
V
Affichage
"sans fin"
;
57
Les instructions de sortie :

pourquoi sont-elles utiles ?
x=1
exemple :
x=1;
while(x<=10)
{
a=1/(x-7);
printf("%f",a);
x++;
}
?
x <= 10
V
a=1/(x-7)
Que va-t-il se passer quand

x=7 ?
Prog. Struct. - C
affichage a
x=x+1
58

continue
x=1
exemple :
x=1;
while(x<=10)
{
if (x==7)
{ printf("division par 0");
x++;
continue;
}
a=1/(x-7);
printf("%f",a);
x++;
}
Prog. Struct. - C
?
x <= 10
V
?
x ==7
V
affiche /0
x=x+1
a=1/(x-7)
affichage de a
x=x+1
59

break
exemple :
x=1;
while(x<=10)
{
a = x-7;
printf("%f", 1/a);
x++;
}
Que va-t-il se passer quand
x=7 ?
Prog. Struct. - C
x=1
F
?
x <=10
V
a=x-7
affichage 1/a
x=x+1
60

x=1
break
exemple :
x=1;
while(x<=10)
{
a = x-7;
if (a == 0)
{
printf("/ par 0");
break;
}
printf("%f", 1/a);
x++;
}
Prog. Struct. - C
?
x <=10
V
a=x-7
?
a == 0
F
V
affiche /0
affichage 1/a
x=x+1
61

return
syntaxe :
return(expression);
exemple :
int main()
{
return(0);
}
Prog. Struct. - C
62
Exemples
Rsolution numrique d'une quation du second
degr
Programme mystre
Affectation et rcurrence
Rsolution de ax2+bx+c=0 :
Organisation du programme
Initialisation :
Acquisition au clavier
des valeurs de a,b,c
Algorithme de calcul
Prsentation des
rsultats sur lcran
Prog. Struct. C
5. Ex : quation du 2nd degr
64
Soit a,b,c,D, x1 et x2 des rels

Lire les coefficients a, b, c
si1 a est gal 0
Alors1 Afficher "trop facile C pas du 2nd degr"
sinon1D b*b - 4 a*c
si2 D est infrieur 0
alors2 Afficher "pas de racines relles"
sinon2
si D est gal 0
3
alors3 x1-b/2a
Afficher x1
sinon3 x1(-b -sqrt(D))/2a
x2(-b+sqrt(D))/2a
Afficher x1 et x2
Fin si3
Fin si2
Fin si1
Prog. Struct. C
65
Rsolution de ax2+bx+c=0 :
Organigramme
Acquisition de a, b, c
VRAI
a= = 0
FAUX
Calcul de D
Affichage C
pas 2 degr
D<0
D==0
V
Pas de racines
Racine
double
2 Racines
distinctes
fin
Prog. Struct. C
66
Le squelette
#include <stdio.h>
#include <math.h>
Directives du pr processeur
int main()
{
/*Dclaration de variables a,b,c,delta,x1,x2*/
/*Entre des valeurs pour a, b, c*/
/*Test du contenu de a*/
//si a 0
/*Calcul de delta */
/*Test sur delta*/
//si delta <0 -> affichage pas de racines
//si delta =0 -> affichage racine double
//si delta >0 -> affichage 2 racines relles
}
Prog. Struct. C
67
II
Fonction main ()
int main()
{
/*Dclaration de variables */
float a,b,c;
float delta;
float x1,x2;
/*Fin de la dclaration des variables*/
Prog. Struct. C
68
Fonction main () suite

/*Entre/saisie des valeurs contenues dans les
variables a, b, c*/
printf("Donnez la valeur de a:");
scanf ("%f",&a);
printf("\nDonnez la valeur de b:");
scanf ("%f",&b);
printf("\nDonnez la valeur de c:");
scanf ("%f",&c);
/* Fin de l'initialisation*/
Prog. Struct. C
69
toujours dans la fonction main ()

/*Test du contenu de a*/
if (a == 0.0)
{
printf("\nCe n'est pas une eq. du second degr");
}
else
{ /*Ouverture du bloc d'instruction a != de 0*/
/*Calcul de
delta */
delta = b*b-4*a*c;
/*Test sur delta*/
if (delta < 0)
printf("\nPas de racines");
else
{ /*ouverture du bloc d'instruction delta >=0*/
Prog. Struct. C
70
Fin du main ()
if (delta == 0) /*Test delta nul*/
{
x1 = -b/(2*a);
printf ("\nRacine double :%f",x1);
}
else
/*Bloc d'intruction delta positif*/
{
x1=(-b-sqrt(delta))/a/2;
x2=(-b+sqrt(delta))/a/2;
printf("x1=%f x2=%f \n",x1,x2);
}/*fin delta>0*/
}/*Fin delta <0*/
}/*Fin a != 0*/
return 0;
}/*Fin programme*/
secondeg.c
Prog. Struct. C
71
Algorithme
mystrieux
Soit a, b, r rels ;
lire(a) ;
lire(b) ;
r <- 0 ;
tant-que (b 0)
si (b est pair)
b <- b/2 ;
a <- 2*a ;
sinon
b <- b-1 ;
r <- r+a ;
fin si
fin tant-que
crire(r) ;
#include <stdio.h>
int main()
{
float a, b,r;
Prog. Struct. C
printf("\nentrez la valeur de a :");

scanf("%f",&a);
printf("\nentrez la valeur de b :");
scanf("%f",&b);
r=0.0;
while (b!=0.0)
{
if(((int)b)%2 ==0)
{
b=b/2;
a=2*a;
}
else
{
b=b-1;
r=r+a;
}
}
printf("\n r = %f",r);
return(0);
72
Rcurrence
Mathmatiquement une relation de
rcurrence, c'est :
xi+1 = f(xi)
avec x0 donn
permet de dterminer toutes les valeurs des

termes de la suite xk.
La valeur d'un nouveau terme se dduit
partir de celle du prcdent.
Prog. Struct. C
73
Affectation
x = expression(x);

x x + 3;
Le nouveau contenu de x (aprs l'excution de
l'instruction) est le rsultat de l'valuation de
l'expression avec le contenu actuel de x.
Prog. Struct. C
74
Exemple : Calculer
Sn =
( 1)
i= 1
i+ 1
Ce qui donne la relation de rcurrence :
Sk = Sk 1 +
Avec
S1 = 1
( 1)
k+ 1
k
recurrence.c
Prog. Struct. C
75
Les pointeurs et les tableaux

1. Les pointeurs
2. Les tableaux
Les chanes de caractres
Les tableaux plusieurs indices
Prog. struct. : C
III-Les pointeurs et les tableaux
76
Les pointeurs : dfinition

Un pointeur est une variable qui contient
l'adresse d'une autre variable :
dune donne,
dune fonction (fera l'objet du prochain cours).
Prog. struct. : C
III-Les pointeurs ...
77
Les pointeurs sur donne

a) Dclaration dun pointeur sur donne
b) Mcanisme de l'adressage indirect
c) Arithmtique des pointeurs
Prog. struct. : C
78
Dclaration dun pointeur sur donne

La dclaration :
Type_donnee *Ident_ptr;
Exemple :
int *pAdi;
pAdi est cod sur 4 octets (adressage 32 bits) et contiendra
l'adresse d'un entier
Prog. struct. : C
79
Mmoire, adresse et pointeur
http://www.siteduzero.com/
Prog. struct. : C
80
Ladressage indirect
int i,*pAdi;
i=10;
pAdi =
Prog. struct. : C
contenant
10
Adresse de i
&i;
*pAdi = 12;
contenu
contenu
pAdi
contenant
Adresse de i Adresse de pAdi
81
Ladressage indirect
*pAdi
pAdi = &i;
= 12;
Prog. struct. : C
contenant
12
Adresse de i
int i,*pAdi;
i=10;
contenu
pAdi
contenu
contenant
Adresse de i Adresse de pAdi
82
& et *
int i;
int *padi;
& pour accder l'adresse d'une donne

ex : &i le numro de la case mmoire
correspondant la variable i padi = &i;
* pour accder au contenu d'une adresse
ex : *padi permet d'accder au contenu de
l'adresse padi contenu de l'adresse de i i
Prog. struct. : C
83
Arithmtique des pointeurs

sur donnes
Additions et soustractions d'entiers sur les
adresses contenues dans les pointeurs
Elles les dplacent de la quantit, qui a t
additionne ou soustraite, multiplie par la
taille en octet du type de l'objet point.
Prog. struct. : C
84
Exemple :
contenant contenu
int i = 80;
double xx=3.1415;
double *pAd;
pAd = &xx;
80
3.1415
100
60
64
80
3.1415
100
pAd = pAd+i;
/*pAd +i*sizeof(double)
c.a.d. 64 + 80*8 octets*/
Prog. struct. : C
60
64
64
60
64
80
3.1415
100
704
nom
i
xx
pAd
i
xx
pAd
i
xx
pAd
85
Les Tableaux
1. Les tableaux mono-dimensionnels

2. Les chanes de caractres
3. Les tableaux de tableaux
Prog. struct. : C
III- ... Les tableaux
86
Qu'est-ce qu'un tableau ?

C'est une suite de variables de mme type, ranges
dans un espace contigu de la mmoire.
Prog. struct. : C
87
Les Tableaux : dclaration et dfinition

Type_donnee Ident_Tab [NbElem];
int, double, char
NbElem le nbre dlments du tableau
constante littrale ou symbolique (#define)
Ident_Tab le nom du tableau le pointeur
sur le tableau contient l'adresse du 1er lment
du tableau
Prog. struct. : C
88
Exemples
double Toto [100];
//Toto est un tableau de 100 doubles
int MyTab [5] = {1,4,8,7,6};

//MyTab est un tableau de 5 entiers initialis :
//MyTab [0]= 1, , MyTab [4]= 6
#define NBELEM 512

float SonTab [NBELEM];
//SonTab est un tableau de NBELEM float
Prog. struct. : C
89
Tableaux un seul indice et Pointeur

int Tab[N];
Tab[0]
Tab[1]
Tab[2]
Tab+i
Tab[N-1]
&Tab[i]
tableau
pointeur
*(Tab+i)
Tab [i]
printf("%d",*Tab); ou printf("%d",Tab[0]);
scanf("%d",Tab+2); ou scanf("%d",&Tab[2]);
Prog. struct. : C
90
Exemple : Saisir et afficher

les lments d'un tableau
Mon premier tableau
Prog. struct. : C
91
Exemple de Tableau 1D :
Les chanes de caractres (string)
Dclaration et initialisation :
char chaine[10];
char source[]="Ma premier chaine de char";
char lettre[]={'t','a','r','a','t','a','t','a',0};
Format :
printf("\nLe contenu de source est %s",source);
scanf("%s",chaine); ou gets(chaine);
Pas besoin de & car le contenu de chaine est une adresse
Prog. struct. : C
92
Chanes de caractres
char *pfin;
char cBonjour [] = "Bonjour";
printf("%s\n", cBonjour);
pfin = cBonjour + 3;
printf("%s\n", pfin);
pfin = cBonjour+strlen(cBonjour);
do
{
printf ("%c",*--pfin);
}while (pfin != cBonjour);
Prog. struct. : C
93
Pour comprendre
'B'
cBonjour
'o'
'n'
'j'
pfin
'o'
'r'
cBonjour+3
printf("%s\n", cBonjour);
pfin = cBonjour + 3;
printf("%s\n", pfin);
Prog. struct. : C
'u'
Bonjour
jour
94
Pour comprendre
'B'
'o'
'n'
'j'
'o'
'u'
'r'
pfin
cBonjour
strlen(cBonjour) renvoie 7
Adresse pointe par pfin
Prog. struct. : C
Adresse pointe par cBonjour+7
95
Chane de Caractres
Exemple
!OG
Prog. struct. : C
96
Tableau de Tableaux
Dclaration :
Type_donne Indent_Tab_Tab[Nlign][Ncol];
Nlign et Ncol sont des constantes entires littrales
ou symbolique.
Exemple :
float mat[3][3];
int trice[3][3]={{1,1,1}, {1,1,1}, {1,1,1}};
printf("%d %d %d", trice[0][0],trice[1][1],trice[2][2]);
scanf("%f",&mat[0][0]);
ou
scanf("%f",mat[0]);
Prog. Struct. - C
III - ... Les tableaux
97
Tableau deux indices

Ligne0
Ligne1
...
NCol
NCol
NCol
NLign x NCol
Prog. Struct. - C
98
Tableau 2 indices et Pointeurs

Tab[i] &Tab[i][0]
Tab[i] est un pointeur constant sur un tableau de nCol
lments
Tab est un pointeur constant sur un tableau dadresses
de tableaux de nCol lments
Tab[i][j] *(*(Tab+i)+j)
int **pptab;
//pptab => pointeur de pointeur
int tableau[4][4]; // contiendra l'adresse d'une
pptab = tableau; // adresse d'entier
Prog. Struct. - C
99
Les fonctions
1.
2.
3.
4.
Prog. Struct. - C
Introduction
Mise en uvre
Passage par valeur et par adresse
Pour aller plus loin
IV - Les Fonctions
100
Jusqu' maintenant, vos programmes

ressemblent a...
#include <stdio.h>
#define N 10
int main()
{ int i;
float TAB[N];
Directives au pr-processeur
La fonction principale
Il ne peut y en avoir qu'une !!
printf("Entrez les valeurs du tableau : ");

for(i=0 ; i<N; i++)
{ scanf("%f",&TAB[i]);
}
printf("Les valeurs du tableau sont :\n ");

for(i=0 ; i<N; i++)
{ printf("%f",TAB[i]);
}
return 0;
Prog. Struct. - C
IV - Les Fonctions
101
Introduction
Une fonction vue par un dbutant
C'est un morceau de programme qui sert faire
quelque chose de prcis.
Entre
Fonction
=
brique
Sortie
Le but : simplifier le code source, pour ne pas avoir

rcrire le mme code plusieurs fois.
Prog. Struct. - C
IV - Les Fonctions
102
Introduction
Une fonction vue du processeur
C'est un code excutable termin par une
instruction de retour situ une certaine adresse
en mmoire.
l'appel de la fonction, le processeur excute le
code partir de l'adresse de la fonction et
l'instruction retour le fait revenir l'instruction
suivant l'appel.
Des donnes peuvent tre transmises la fonction
en paramtres. Lors du retour, une valeur peut tre
rcupre/renvoye.
Prog. Struct. - C
IV - Les Fonctions
103
Instruction i ;
Appel MaFonction() ;
Adresse
Instruction i+2 ;
MaFonction Ligne n1 de MaFonction()

La suite de MaFonction()
Instruction return();
Prog. Struct. - C
IV - Les Fonctions
104
Exemple avec la fonction sqrt() :

Instruction i ;
Adresse
X = sqrt(4) ;
Instruction i+2 ;
4
sqrt(argument) if (argument>0)
Le calcul de sqrt(4)
return(2)
Prog. Struct. - C
IV - Les Fonctions
Retour de 2
105
Une fonction vue du programmeur

c.a.d. vous
Les fonctions facilitent l'organisation et la mise au
point du programme puisqu'il est divis en
fonctions qui ralisent chacune une partie de la
tche.
Un programme est un ensemble de fonctions,
qui s'excute partir de la fonction main ()
Un
programmeur
professionnel
bibliothques de fonctions pour
dveloppement de son application.
Prog. Struct. - C
IV - Les Fonctions
utilise
des
acclrer le
106
Instruction i;
MaFonction(10,x+y,z);
Instruction_suiv;
Passage de
x+y paramtres
10
MaFonction {
Instructions
De MaFonction
return;
}
Prog. Struct. - C
IV - Les Fonctions
107
Fonction : Mise en uvre

#include <stdio.h>
/* 2) Le prototypage */
int main()
{
/* 3) L'appel */
}
/* 1) La dfinition */
Prog. Struct. - C
IV - Les Fonctions
108
1) La Dfinition
Localisation :
#include <stdio.h>
int main()
{
//Dfinition des fonctions
Exemples de fonctions :
Arguments ou
paramtres
void AfficheTableau(float *ptab, int nlignes)

{ int i;
for (i=0; i<nlignes ; i++)
{ printf("%f", *(ptab+i) );
}
}
double CalcDisc(double Arga,double Argb,double Argc)
{
return Argb*Argb-4*Arga*Argc;
}
Prog. Struct. - C
IV - Les Fonctions
109
2) Le Prototypage
Type_Ret Ident_fonc (,Type Argument,);
Exemples de prototypages :
void AfficheTableau(float *ptab, int nlignes);
double CalcDiscri (double Arga,double Argb,double Argc);
O a se trouve dans le programme ?

#include <stdio.h>
// c'est ICI pour le prototypage des fonctions !!!
int main()
{
Prog. Struct. - C
IV - Les Fonctions
110
3) L'appel de la fonction
Paramtres de la fonction
{
double ValDisc;
ValDisc = CalcDisc (a,b,c);
O fait-on appel la fonction ?
Dans n'importe quelle dfinition de fonction, par ex.

dans la fonction main(), y compris dans sa propre
dfinition Rcursivit
Prog. Struct. - C
IV - Les Fonctions
111
Ma premire fonction
\fonctions\exemple1.prj
Prog. Struct. - C
IV - Les Fonctions
112
2 types de fonctions
1) Celles qui ne retournent rien (void).
Elles sont galement appeles procdures.
void nom_fonction(dclarations_d'arguments)
EXEMPLE : /* Procdure affichant le produit de deux entiers */
/* Paramtres d'entre : deux entiers, Type retour : rien */
void affiche_produit (int iExp1, int iExp2)
{
int iProduit;
iProduit = iExp1 * iExp2;

printf ("Le produit de %d et %d est gal %d",
iExp1, iExp2, iProduit);
Prog. Struct. - C
IV - Les Fonctions
113
2 types de fonctions
2) Celles qui retournent quelque chose (elles
renvoient une valeur).
Pour cela, il faut utiliser l'instruction return :
return expression;
EXEMPLE :
/* Une fonction calculant le produit de deux entiers */
/* Paramtres d'entre : deux entiers, Type retour : entier */
int calcule_produit (int iExp1, int iExp2)

{
int iProduit;
iProduit = iExp1 * iExp2;

return iProduit;
Prog. Struct. - C
IV - Les Fonctions
114
2 types d'arguments :
1) ceux passs par valeur
On indique au compilateur
que fonction1 est une
fonction qui ne retourne
rien et qui admet pour
paramtre un double
//Prototypage
void fonction1(double z);
//Dfinition
void fonction1(double z)
{
z = z * 2.0;
printf("z = %lf\n",z);
}
Lors de l'appel de la fonction, le
contenu de la zone repre par z
sera x 2
Prog. Struct. - C
On donne le code de la
fonction. Le compilateur
rserve 8 octets de la pile
dsigns par z. Pour le
moment, le contenu de cette
zone est indtermin.
IV - Les Fonctions
115
Excution : Appel de la fonction

/*A l'intrieur de la
fonction appelante par
exemple le main()*/
Zone de 8 octets
rserve pour x
20.0
Zone de 8 octets
rserve pour z
20.0
double x = 20.0;
...
fonction1 (x);
pile
Prog. Struct. - C
IV - Les Fonctions
116
Lors de lexcution
Zone de 8 octets
rserve pour x
Hors de porte
de fonction1
20.0
void fonction1 (double z)

{
z = z*2.0;
}
Zone de 8 octets
rserve pour z
20.0
40.0
pile
Prog. Struct. - C
IV - Les Fonctions
117
Aprs lexcution d'une fonction o les

paramtres sont passs par valeur
Zone de 8 octets
rserve pour x de
nouveau accessible
20.0
La zone mmoire rserve pour z nest plus

accessible,
et le contenu de x na pas t modifi !
Prog. Struct. - C
IV - Les Fonctions
118
2 types d'arguments :
2) ceux passs par adresse
On indique au compilateur que :
- fonction2 ne retourne rien,
- et admet pour paramtre un pointeur sur double
//Prototypage
void fonction2(double *pz);
//Dfinition
void fonction2 (double *pz)
{
*pz = (*pz)*2.0;
}
4 octets dsigns par pz

sont rservs dans la
pile.
Ce qui est point par pz sera x 2 lors de l'appel de la fonction.
Prog. Struct. - C
IV - Les Fonctions
119
Excution :
Appel de la fonction
Zone de
8 octets
rserve
par x
20.0
//A l'intrieur de la
fonction appelante
double x = 20.0;
...
4 octets
rservs
par pz
fonction2 (&x);
&x
pile
Prog. Struct. - C
IV - Les Fonctions
120
Au sein de la fonction
x inaccessible dans fonction2,
mais atteint grce l'adressage
indirect
20.0
40.0
void fonction2 (double *pz)

{
*pz =(*pz)*2.0;
}
4 octets rservs pour pz
&x
pile
Prog. Struct. - C
IV - Les Fonctions
121
Aprs lexcution
8 octets
rservs pour x de
nouveau accessible
40.0
La zone mmoire rserve pour pz

nest plus accessible
et le contenu de x a t modifi par
adressage indirect !
Prog. Struct. - C
IV - Les Fonctions
pile
122
Ma deuxime fonction
val_et_adr.prj
Exemple
Prog. Struct. - C
IV - Les Fonctions
123
Rappels sur les fonctions
3 tapes pour la mise en uvre : le prototypage,

la dfinition, et l'appel.
Les arguments/paramtres : constante, variable,
expression, fonction
Si pas void alors return la fin de la dfinition
Le passage des arguments peut se faire par

valeur, ou par adresse lorsqu'on souhaite
modifier la variable passe en argument.
Prog. Struct. - C
IV - Les Fonctions
124
Squelette d'un programme

Zone des directives de prprocesseur
#include
Que se cache-t-il dans stdio.h ?
#define
Dclaration des variables de porte fichier
Prototypage des fonctions
Dfinition de la fonction main()
int main()
{
}
Dfinition de vos fonctions
Prog. Struct. - C
IV - Les Fonctions
125
A RETENIR !!!
Pour modifier le contenu d'une variable

dclare dans la fonction appelante par la
fonction appele, il est ncessaire de passer en
paramtre l'adresse de cette variable.
Donc, dans le prototypage et la dfinition de la
fonction, l'argument doit tre un pointeur.
Prog. Struct. - C
IV - Les Fonctions
126
Pour aller plus loin

1.
2.
3.
4.
La rcursivit
La porte des variables : locales ou globales
Les tableaux comme arguments
Les pointeurs sur fonctions
Prog. Struct. - C
IV - Les Fonctions
127
1) La Rcursivit :
La fonction s'appelle elle-mme !
Exemple :
double Factorielle (int n);
double Factorielle (int n)
{
if (n <= 0)
return 1;
}
//Prototype
Condition d'arrt
return n*Factorielle (n-1);
Appel rcursif
factorielle.prj
Prog. Struct. - C
IV - Les Fonctions
128
2) La porte des variables

Les variables locales sont temporaires. Elles
sont dclares au sein de fonctions.
Les variables globales sont permanentes. Elles
sont dclares en en-tte du programme.
varlife.prj
Attention ne pas toutes

les appeler n, i ou j!!!
Prog. Struct. - C
IV - Les Fonctions
129
3) Tableaux passs en
paramtres une fonction
Tableaux une dimension (un indice)
Type_ret Ident(Type_Tab *ptab, int nSize, );
OU
Type_ret Ident(Type_Tab Tab[], int nSize, );
ex : void affichetableau(float *ptab, int Nb);
Prog. Struct. - C
IV - Les Fonctions
130
3) Tableaux passs en
paramtres une fonction
Tableaux deux dimensions (2 indices)
Type_ret Ident(Type_Tab Tab[][NCOL], int nLign, );
OU
Type_ret Ident(Type_Tab (*pTab)[NCOL], int nLign, );
ex : void affiche2D(float *ptab[10], int Nblig);

Prog. Struct. - C
IV - Les Fonctions
131
4) Les Pointeurs sur fonction

Dclaration
Affectation
Utilisation
Prog. Struct. - C
IV - Les Fonctions
132
Dclaration d'un pointeur sur

fonction
Type_Val_Ret(*Ident_ptr_Fonc)(Signature_fonc);
Liste ordonne des types des
arguments de la fonction sans
les identificateurs des
arguments
Signature_fonc
Exemple
double (*pFonc)(double);
Prog. Struct. - C
pFonc est un pointeur sur une

fonction retournant un double et
admettant un double en
argument.
IV - Les Fonctions
133
Initialisation, Affectation d'un

pointeur sur fonction
double (*pFonc)(double);
Ncessite
#include <math.h>
double (*pTabFonc [3])(double)={sin,cos,tan};

pFonc = MaFonc;
Le prototype de MaFonc doit tre connu par le
compilateur.
Prog. Struct. - C
IV - Les Fonctions
134
Pointeurs sur fonction
pointfonct.prj
Prog. Struct. - C
IV - Les Fonctions
135

1. Les structures
2. Les unions
3. Les numrations
http://iusti.polytech.univ-mrs.fr/~bergougnoux/enseignement.htm
Prog. struct. C

servent crer ses
propres types de variables
Pour manipuler :
- des nombres complexes,
- des cordonnes (x,y,z) de points,
- des images,
....
- un ensemble de variables qui peuvent tre de type
Prog. struct. C
V- Les structures
137
De la fiche la structure
Pour grer une clientle, une bibliothque, un stock de
pices dtaches, etc
on a besoin d'informations sur chacun des lments de
l'ensemble.
Ces informations sont consignes dans des fiches qui
sont remplies grce un formulaire unique.
C'est le formulaire qui structure les informations
contenues dans les fiches.
Prog. struct. C
V- Les structures
138
La fiche d'un lve Polytech

Nom :
PIGNON Prnom : Franois
Adresse : 12 place du march 13013 Marseille

Dpartement Polytech :
MT
Anne : 3
Spcialit :aucune
Login : PIGNMT12
Password : juste12
Email : Francois.Pignon@polytech.univ-mrs.fr
Prog. struct. C
V- Les structures
139
Traduction Informatique
Formulaire
Type de donne
Structure struct
modle
Fiche
Variable de type
struct
objet
Fichier
Tableau ou liste de Ensemble

variables de type
d'objets
struct
Prog. struct. C
V- Les structures
140
Dclaration du nouveau type

de donne
Syntaxe :
struct nom_struct
{
type_1 ident_champ1;
type_2 ident_champ2,ident_champ3;
type_N ident_champM;
}nom_var1, ... ,nom_varP;
Prog. struct. C
V- Les structures
141
Dclaration du nouveau type

de donne
Localisation : Aprs les include
#include <stdio.h>
struct nom_struct
{
type_1 ident_champ1;
type_2 ident_champ2,ident_champ3;
};
//Les prototypes des fonctions
int main()
{
}
Prog. struct. C
V- Les structures
142
Exemple 1 : Dfinition du type POLYTECH

struct
{
char
char
char
int
int
int
char
char
char
};
POLYTECH
Nom[80];
Prenom[80];
Adresse[200];
Depart;
Annee;
Spec;
Login[10];
Passw[8];
Email[30];
Prog. struct. C
9 champs avec des

identificateurs pas
contigus mais la suite
V- Les structures
143
Dclaration d'une donne

Syntaxe :
struct nom_struct nom_var;
Exemple :
struct POLYTECH UnEleve;
//variable
struct POLYTECH TabElev[250]; //tableau
struct POLYTECH *pElev;
//pointeur
Prog. struct. C
V- Les structures
144
Accs aux champs de la donne

Syntaxe :
nom_struct.nom_var
ex : UnEleve.Annee = 1;
Si pointeur sur type nom_struct :

nom_ptr_struc->nom_var
(*nom_ptr_struc).nom_var
exemple : TabElev->Annee = 1;
Prog. struct. C
V- Les structures
145
Ex 1 : accs aux champs de POLYTECH

int main()
{
struct POLYTECH TabElev[250];
struct POLYTECH UnEleve;
printf("\nNom de l'lve :");

scanf ("%s",UnEleve.Nom);
TabElev[10] = UnEleve;
(TabElev+10)->Annee = 1;
}
Prog. struct. C
V- Les structures
146
Exemple 1 :Utilisation suite

Arguments et paramtres d'une fonction,
sans la structure :
void NewElev(char *pNom,char *pPrenom,char
*pAdr,int *pDepart,int *pAnnee,int
*pSpec,char *lplogin,char *ppass,char
*pemail);
En utilisant la structure :
void NewElev(struct POLYTECH *pNouveau);
structures/POLYTECH.prj
Prog. struct. C
V- Les structures
147
Dfinition de type compos

Structure nomme
struct tComplex
{
double Re;
double Im;
};
ce nouveau type suit le

modle struct tComplex
typedef struct tComplex Complex;
dfinition d'un nouveau type

Prog. struct. C
V- Les structures
Le nom de ce nouveau
type est Complex
148
Exemple 2 : Reprsentation des

nombres complexes
Complex zI = {0,1.0};
Complex *pz;
Complex zTabVal [10];
Dclarations des variables

zI, pz et zTabVal de type
Complex
pz = &zI;
pz->Re = sqrt(2)/2;
pz->Im = pz->Re;
zTabVal[0].Re = 11.5;
Utilisation de ces
variables
(zTabVal+5)->Im = sqrt(2);
Prog. struct. C
V- Les structures
149
Union
Ensemble de variables de type diffrents pouvant
alternativement occuper la mme zone mmoire.
Syntaxe de dclaration :
la mme que pour une structure ...
union jour
{ char lettre;
int numero;
};
Le stockage en mmoire : tous les champs de l'union
commencent la mme adresse. La taille de l'union est

donc celle du plus grand champ. On peut donc atteindre
une mme zone mmoire de plusieurs faons.
Prog. struct. C
V- ... Les unions
150
numration
Permet de dfinir un type par la liste des valeurs qu'il
peut prendre.
Syntaxe :
enum modele
{ constante_1,constante_2,,constante_n
};
Exemple :
enum tBool{FAUX,VRAI};
typedef enum tBool BOOLEEN;
...
enum jours_ouv{lundi,mardi,mercredi,jeudi,vendredi};
Prog. struct. C
V-... les numrations
151
Exemple
enum tdepart{GC,GII,ME,MT};
typedef enum tdepart DEPART;
POLYTECH *pElev;
/*Mettre une adresse valide dans pElev*/
pElev->Depart = MT;
Prog. struct. C
V- Les structures
152
La gestion de fichiers
1.
2.
3.
4.
Les Flots
Ouverture / Fermeture d'un fichier
Lecture / criture dans un fichier
Formats
1 Fichier sur 1 Disque

Chemin d'accs "path" :
C:\Repertoire\SousRep1\...\SousRepN\Nom.ext
Structure arborescente de
rpertoire, sous rpertoires,
Unit logique
Nom du Fichier
et son extension
Le mode d'accs
Les ventuels attributs de protection.
Prog. struct. C
VI- La gestion de fichiers
154
Gestion de Fichiers
pour le programmeur
Transfrer une ou des informations d'une
source vers une destination.
Donc grer un flot d'informations.
Prog. struct. C
155
Flot dinformations
Source :
Destination :
Mmoire
de masse
Mmoire de
masse
Clavier
Port Srie
Mmoire
Flot
Flot//stream
stream
octets
Console
Port Srie
Mmoire
Carte SD
Carte SD
...
...
Prog. struct. C
156
La direction du Flot
Dans la gestion d'un flot, au moins l'une des
destinations est la mmoire de l'ordinateur.
Pour crire dans le fichier des informations
stockes dans la mmoire, il faut accder au
fichier en criture.
Le flot est en sortie.
Pour lire les informations du fichier et les stocker
dans la mmoire, on accde au fichier en lecture.
Le flot est en entre.

Prog. struct. C
157
<stdio.h>
standard input output
C'est l qu'est dfinie la structure FILE !
Prog. struct. C
158
Ouverture/Fermeture
de flots en C (ANSI)
Pour toutes les fonctions de gestion des
flots, il faut un pointeur sur la structure FILE
dfinie dans stdio.h.
Le flot est ouvert en appelant fopen() qui
affecte une valeur cette variable pointeur.
Le flot est ferm par fclose().
Prog. struct. C
159
Les Modes d'ouverture

Les flots/fichiers peuvent tre ouverts en mode :
Lecture "r" la destination existe
"r+" possibilit d'criture
Ecriture "w" la destination est cre ou ouverte
"w+" possibilit de lecture
Ajout
"a" criture la fin du fichier

"a+" possibilit de lecture
Si la lecture ou l'criture doivent tre faits en binaire,

il faut ajouter "b" au mode (ex : "rb").
Prog. struct. C
160
Les Fonctions gnrales

Cration, ouverture d'un fichier
FILE *fopen(const char *nom,const char *mode)
Fermeture d'un fichier
FILE *fclose(FILE *stream)
Cration d'un fichier temporaire
FILE *tmpfile(void)
Test de fin d'un fichier
int feof(FILE *stream)
Prog. struct. C
161
Exemple
#include <stdio.h>
int main()
{
//pointeurs sur fichier
FILE *pFascii,*pFbin;
pFascii = fopen("totoascii.txt","w");
pFbin = fopen("totobin.moi","wb");
fclose(pFascii);
fclose(pFbin);
}
Prog. struct. C
texte_bin.prj
162
Les Flots prdfinis

3 pointeurs sur structure FILE sont grs
par le systme d'exploitation :
stdin gre les informations envoyes par
le clavier (entre).
stdout gre les informations diriges vers
l'cran (sortie).
stderr dirige les informations gnres par
les erreurs vers un priphrique de sortie.
Prog. struct. C
163
Exemple
#include <stdio.h>
int main()
{
fprintf(stdout,"1ere alternative printf()\n");
fputs("\n En voila une autre",stdout);
}
ecran.prj
Prog. struct. C
164
criture dans un fichier

Ecriture au format texte :
int fprintf(FILE *pfile,const char *format,)
/* crit la chane formate dans le fichier, retourne le nbre de

caractres crits, ou un nombre <0 si erreur */
int fputc(int caractere,FILE *pfile)
/* crit le caractre dans le fichier, le caractre crit est retourn,

EOF sinon */
int fputs(const char *s,FILE *pfile)
/* la chane s dans le fichier, et retourne une valeur positive ou

nulle, EOF s'il y a eu une erreur */
Ecriture au format binaire :

size_t fwrite(const void *source,size_t taille,
size_t nombre,FILE *pfile)
/* crit nombre objets, chacun ayant la taille indique, les uns la suite
des autres l'adresse indique par source. Renvoie le nombre d'objets
crits, qui peut tre infrieur au nombre demand (en cas d'erreur) */
Prog. struct. C
165
Lecture dans un fichier

Lecture au format texte :
int fscanf(FILE *pfile,const char *format,)
/* Lit la chane formate dans le fichier et retourne le nombre de

caractres luts, ou un nombre <0 si erreur */
int fgetc(FILE *pfile)
/* Renvoie le caractre suivant sur le flot indiqu, ou EOF si la fin

du fichier est atteinte ou si une erreur survient. C'est une vraie
fonction */
int fgets(char *s,int n,FILE *pfile)

/* Lit des caractres dans le fichier et les place dans l'espace
point par s. S'arrte lorsqu'elle a lu n-1 caractres ou lorsqu'elle
a rencontr un caractre '\n' */
Lecture au format binaire :

size_t fread(void *dest, size_t taille, size_t
nombre, FILE *pfile)
/* Lit sur le flot indiqu le nombre objets, chacun ayant la taille
indique, et les copie les uns la suite des autres dans l'espace
point par destination */
Prog. struct. C
166
Positionnement dans un fichier

Dplacement :
int fseek(FILE *pfile,long deplacement,int orig)
avec orig =
SEEK_SET le dbut du fichier,

SEEK_CUR la position courante,
SEEK_END la fin du fichier
Re-positionnement au dbut du fichier :

void rewind(FILE *pfile)
ConnatreA la
position dans le fichier :
u
tilis *flot, fpos_t *ptr)
void fgetpos(FILE
e
r av
ec p
rca:
Fixer la position dans le fichier
utiofpos_t *ptr)
void fsetpos(FILE *flot, const
n !!
/*Place dans ptr la position courante dans le fichier indiqu en

vue de son utilisation par fsetpos*/
Prog. struct. C
167
Renommer ou Supprimer
un fichier
Renommer
int rename(const char *ancienNom, const char
*nouveauNom);
Supprimer
int remove(const char *FichieraSuppr);
Prog. struct. C
168
Formats d'criture
%[flags][width][.precision][{h|L|l}]type
flags (-,+,0, ,#) : mise en forme du texte
width : Longueur minimum du texte
.precision : Nombre de chiffres aprs la virgule (.)
type :
1) Flottants e,E,f,g,G
2) Entiers gnraliss c,d,i,o,u,x,X
3) Chanes de caractres s
[{h|L|l}] en option h pour court, l ou L pour long

Prog. struct. C
169
Formats de lecture
%[*] [width] [{h | l }]type
Mme signification de width et de type.

* signifie que la lecture suivante sera faite, mais
non transfre en mmoire.
Prog. struct. C
170
Flots textes formats

En criture :
int printf (const char *format,)
int fprintf (FILE *pfile,const char *format,)
int sprintf (char *pdesti,const char *format,)
En lecture :
int scanf (const char *format,)
int fscanf (FILE *pfile,const char *format,)
int sscanf (const char *psource, const char
*format,)
Prog. struct. C
171
Exemple 1 :
texte format -> fichier binaire
...
int main()
{
FILE *srce; /* fichier de texte */
FILE *dest; /* fichier binaire */
...
if ((srce = fopen(nomfich, "r")) == NULL)
exit(ERREUR_OUVERTURE);
...
for (;;)
//tant qu'il y a des choses lire
{
if ((nb=fscanf(srce, "%s %s\n", art.nom, art.prenom)) != 2)
break;
...
}
...
}
Prog. struct. C
fichier.prj
172
Exemple 2 : les formats

#include <stdio.h>
int main()
{
const double pi=4*atan(1);
printf("%lf\n",pi);
printf("%1.3lf",pi);
}
formats.prj
Prog. struct. C
173
Programmation modulaire
(multi-fichiers)
1.
2.
3.
4.
Gnralits
Mise en uvre
Macros
Variables de porte fichier
Gnralits
Un logiciel doit tre conu comme la runion de
plusieurs modules,
Chaque module regroupe des fonctions de mme
nature (Graphisme, Algorithmes principaux,
interface utilisateur, ),
Un seul des modules contient la fonction main ().
Prog. Struct. C
IX - Prog. Modulaire
175
Les avantages
En sparant les fonctionnalits du projet en units
le moins possible interdpendantes, on simplifie la
mise au point du logiciel qui se fait module par
module.
La compilation est beaucoup plus rapide, car seuls
les modules modifis sont compils.
Certains modules (sils sont bien conus) peuvent
tre r-utiliss dans dautres projets.
Prog. Struct. C
176
La mise en uvre
Programme monofichier
En-tte
Programme modulaire
Fichiers .h
Module
Fonction main
Fichier .c
Sans fonction
main()
Dfinition de
vos fonctions
Prog. Struct. C
Fichiers .c
177
Consquences :
Le fichier *.prj s'agrandit
Prog. Struct. C
178
Le contenu de l'en-tte
Directives de pr-processeur : #xxxx
Ex : #include <stdio.h> ou #define PI 3.14159
Dclaration des types utilisateurs : struct

Ex : struct POLYTECH
Dfinition des variables de porte fichier (globales)

Ex : static int panelhandle;
Dclaration des variables dfinies de manire externe

Ex : extern
Dclaration des prototypes des fonctions

Ex : void ma_fonction(void);
++++ Mon_Fichier.h
Prog. Struct. C
179
La directive #include
Syntaxe :
#include <stdio.h>
#include "[nomchemin\\]nomfichier.h"
Action : Inclure
Avant la compilation, le pr-processeur met
en lieu et place de la directive le fichier.h
Prog. Struct. C
180
La directive #include
/* C'est le contenu du
fichier.h qui est
recopi en en-tte
du fichier.c */
#include "fichier.h"
int main()
{
}
/*fichier .c */
Prog. Struct. C
181
La directive #define
Syntaxe :
#define BUFSIZE 512
#define PI 3.14159
Action : Rechercher/Remplacer
Partout o la chane de caractres BUFSIZE
est rencontre, elle est remplace par 512
La compilation se fera sur le code transform!
Prog. Struct. C
182
#define
pour la taille des tableaux
#define NMAX 10
....
int main()
{
float vect[NMAX];
Le programme est
dvelopp avec 10 pour
remplacer NMAX.
Aprs le programmeur
pourra mettre 10000 ...
for(i=0 ; i<NMAX; i++)

{ ....
}
}
Prog. Struct. C
183
Comment faire une Macro ?

Au sein d'un #define
Exemple :
#define MAX(a,b) (((a)>(b))?(a):(b))
MAX(expr1,expr2) sera utilise comme
(((expr1)>(expr2))?(expr1):(expr2))
Les parenthses servent fixer les priorits.
Prog. Struct. C
184
Comment faire une Macro ?

Autre Exemple :
#define MAJEUR(age) if (age>=18)\
printf("Vous etes majeur");
int main()
{
MAJEUR(22);
}
Lors de l'excution il s'affichera :
Vous etes majeur
Prog. Struct. C
185
Avantages des macros

Remplacer des fonctions courtes.
Le temps dexcution du programme puisquil ny a
pas dappel de fonction.
Mais le code excutable est plus long.
Les compilateurs modernes utilisent les macros pour
gnrer automatiquement du code rptitif la place du
programmeur.
Prog. Struct. C
186
Dfinition de constantes
#define CONSTANTE
Il est alors possible d'utiliser #ifdef et #endif
#define WINDOWS
#ifdef WINDOWS
//code source pour Windows
#endif
#ifdef LINUX
//code source pour Linux
#endif
Prog. Struct. C
187
Les variables globales

en programmation modulaire
Une variable globale a la porte et la dure

de vie du programme.
Prog. Struct. C
188

en programmation modulaire
Pour tre reconnue par le compilateur dans

d'autres modules du programme, elle doit :
- y tre dclare mais sans rservation de
mmoire,
- et prcde de extern dans un fichier .h
inclure dans les fichiers .c, o cette variable
est utilise.
Prog. Struct. C
189

(suite)
Si, on veut restreindre la porte de cette
variable au seul module o elle a t dfinie, on
fait prcder sa dfinition de static.
Dans dautres modules, une autre variable de
porte fichier de mme identificateur pourra
tre dfinie sans conflit de dclaration.
Prog. Struct. C
190
Exemple
modulaire.prj
Prog. Struct. C
191
Dpartement
Dpartement Gnie
Gnie Civil
Civil &
& Dpartement
Dpartement Mcanique
Mcanique nergtique
nergtique
Allocation Dynamique
de Mmoire
1. Gnralits
2. Les fonctions malloc() & Cie
Quand l'utiliser ?
Si le nombre dobjets stocker dans le
tableau nest connu qu lexcution, il faut
avoir recours lallocation dynamique.
Pour les tableaux plusieurs indices mme si
les dimensions sont connues priori.
Pour stoker des donnes volumineuses.
Prog. struct. C
X - Alloc. dyn. mem.
193
Dclaration de variables
=
Demande d'allocation mmoire
int maVariable = 12;
1) le programme demande Windows la permission
d'utiliser un peu de mmoire,
2) Windows rpond en indiquant o votre
programme peut stocker maVariable
il lui alloue une adresse
3) lorsque la fonction est termine, maVariable
est automatiquement supprime de la mmoire.
Votre programme dit Windows "Je n'ai plus besoin
de cet espace mmoire"
Prog. struct. C
194
Connatre la taille des variables grce

sizeof()
sizeof(char) 1
sizeof(short int) 2
sizeof(int) 4
sizeof(double) 8
sizeof(int *) 4
Prog. struct. C
195
Configuration de la mmoire
pendant lexcution
Tas
Programme
Variables
statiques
Le tas (heap) est

la mmoire
inutilise lors de
lexcution du
programme.
Pile
OS (windows par ex.)

C'est l que va se faire l'allocation dynamique de
mmoire.
Prog. struct. C
196
La Mise en uvre
Il faut :
Une variable de type pointeur sur la donne
stocker
Utiliser la fonction malloc() ou une similaire
pour affecter une adresse cette variable.
Librer la mmoire lorsque l'on en n'a plus
besoin avec la fonction free().
Prog. struct. C
197
La fonction malloc()
Prototype dans <stdlib.h> ou <malloc.h> :
void * malloc (size_t nSize);
Appel :
typedef struct POLYTECH_EL ELP;
ELP *pTabElev;
int nNbEl;
pTabElev = (ELP*)malloc(nNbEl* sizeof(ELP));

On type l'adresse
Prog. struct. C
Taille d'une variable de type ELP
198
La fonction malloc()
Erreur mmoire insuffisante :
Quand la demande ne peut pas tre satisfaite,
la fonction malloc()retourne le pointeur NULL.
Do le test derreur :
if (pTabElev == NULL)
{
Gestion Erreur
}
Prog. struct. C
199
Allocation pour un tableau 2

dimensions
Exemple :
double **MAT;
...
MAT = malloc(nl * sizeof(double *));

if (MAT == NULL)
return 0;
for (i = 0; i < nl; i++)
{
MAT[i] = malloc(nc * sizeof(double));
}
Prog. struct. C
200
La fonction calloc()
Prototype :
void *calloc(size_t nElem,size_t Taille_Elem);
Appel :
pTabElev =(struct POLYTECH_EL*)calloc (nNbEl,
sizeof(struct POLYTECH_EL));
Mise 0 des octets rservs.

Si mmoire insuffisante ragit comme malloc()
Prog. struct. C
201
La fonction realloc()
Prototype :
void *realloc (void *ptrAlloc,size_t New_Size);
Si la taille de la mmoire prcdemment alloue doit tre

rduite.
Le contenu du pointeur et de la mmoire sont prservs.
Prog. struct. C
202
La fonction free()
Prototype :
void free (void * pMemAlloue);
Appel :
free(pTabElev);
Action :
Libre la zone mmoire alloue par une des fonctions de
la famille malloc().
Doit sutiliser ds que lon na plus besoin de cette
mmoire.
Prog. struct. C
203
La fonction free()
Si la fonction free() a pour paramtre la valeur
NULL, elle sexcute sans erreur et sans rien faire.
si l'adresse passe free() ne rsulte pas dun

appel
! une fonction de la famille malloc(), le
rsultat est catastrophique !!!
Prog. struct. C
204
Exemple
allocat.prj
Prog. struct. C
205
Les listes chanes

- a sert organiser ses donnes en mmoire.
- C'est beaucoup plus flexible qu'un tableau !!!
- mise en uvre avec des structures...
Prog. struct. C
206
Listes chanes vs Tableaux
Une fois cr, on ne

peut plus le modifier !
1 Tableau
Prog. struct. C
207
Listes chanes vs Tableaux
1 Liste
Prog. struct. C
Une fois cre, on peut la modifier !

208
Construction d'une liste

chane
Exemple : une liste de nombres ou d'tudiants
Comment crer un
typedef struct Element Element;

struct Element
{
int nombre;
Element *suivant_sur_la_liste;
};
Prog. struct. C
209
Pour contrler l'ensemble de la liste, il faut :
typedef struct Liste Liste;

struct Liste
{
Element *premier_sur_la_liste;
};
Puis il faut crire les fonctions grant la liste :
- pour l'initialiser,
- pour ajouter un lment,
- pour supprimer un lment,
- pour afficher le contenu de la liste,
- pour supprimer la liste entire..
Prog. struct. C
210
Exemple de fonction pour l'initialisation :

Liste *initialisation(void)
{
Liste *liste=malloc(sizeof(*liste));
Element *element=malloc(sizeof(*element));
if (liste==NULL || element==NULL)
{
exit(EXIT_FAILURE);
}
element->nombre=0;
element->suivant_sur_la_liste=NULL;
liste->premier_sur_la_liste=element;
Prog. struct. C
211
Pour en savoir plus

A la bibliothque en salle 112 :
H. Garreta, C: Langage, bibliothque, applications,
InterEditions (1992)
B. Kernighan et D. Ritchie, Le Langage C, Masson
(Dernire Edition) - Pour se perfectionner.
B. Gottfried, Programmation en C, Srie Schaum,
Pour les exercices.
H. Schildt, Rfrence Complte C++, First Interactive
(2002).
Progr. struct. - C
Bibliographie
212
Pour en savoir plus
Cours de C sur le Web :

http://www.commentcamarche.net
Henri Garreta
http://www.dil.univ-mrs.fr/~garreta
http://c.developpez.com/cours
http://www.siteduzero.com/tutoriel-3-14189-apprenez http://iusti.polytech.univ-mrs.fr/~bergougnoux/enseignement.htm
IDE en open source Dev-C++

tlcharger partir de
http://www.commentcamarche.net
Progr. struct. - C
Sources
213

Cours de C

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Cours de C

Încărcat de

Drepturi de autor:

Formate disponibile

Dpartement Gnie Civil & Dpartement Mcanique nergtique

Avec la participation de Jean-Luc FIRPO

Mini projet & oral

Projet & oral

En pratique : le 1er TD c'est

3.1, Lundi 07/10, 10h

Les objectifs de ces cours,

Qu'est-ce qu'un Algorithme ?

Qu'est-ce qu'un Algorithme ?

Conception d'un Algorithme :

Recette du gteau la crme de marrons :

Prchauffer le four 180C

Comment raliser un programme ?

Langage C : histoire et qualits

Dpartement Gnie Civil & Dpartement Mcanique nergtique

Les bases du langage C

Types, variables et constantes

Une variable sera toujours dfinie avant utilisation :

1. Les types de donnes

Les types de donnes

dfinit une convention de codage de l'information

1 nombre : entier ou rel

1. Les types de donnes

Les nombres entiers

-32 768 32 767

Entier court non

-2 147 483 648

Entier non sign

0 4 294 967 295

-2 147 483 648

Ent. long non

0 4 294 967 295

1. Les types de donnes

Les nombres rels

Rel simple prcision 4

1,7 10-308 1,7 10308

3,4 10-4932 3,4 104932

1. Les types de donnes

des nombres rels

exposant = 7+127=134=1000 0110

1. Les types de donnes

1. Les types de donnes

Contient 32 caractres max

Les variables : leurs noms

comporte des espaces

Ce que vous allez faire le + souvent :

les oprateurs de calcul

Les oprateurs de calcul

Met la valeur 3.00

Les oprateurs d'assignations

peut aussi s'crire x+=2;

additionne deux valeurs et stocke le rsultat dans la

soustrait deux valeurs et stocke le rsultat dans la variable

multiplie deux valeurs et stocke le rsultat dans la variable

divise deux valeurs et stocke le rsultat dans la variable

Les oprateurs d'incrmentation

y=x++; y=x; x=x+1; //y=3, x=4

y=++x; x=x+1; y=x; //x=y=5

Les oprateurs de comparaison

Exemple Rsultat si x vaut 7

Retourne 1 si x est gal 3,

Retourne 1 si x est infrieur

Retourne 1 si x est infrieur ou