2. Progr. struct. - C Introduction 2
UE :
Mathématiques & 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 Rémy Bulot
3. Progr. struct. - C Introduction 3
Laurence BERGOUGNOUX Bureau 208
François GUILLARD Bureau 242
Christian MARIANI Bureau 321
Fabien PETITPAS Bureau 319B
Jérôme VICENTE Bureau 326
Prenom.Nom@polytech.univ-mrs.fr
ou
Prenom.Nom@univ-amu.fr
Avec la participation de Jean-Luc FIRPO
L'équipe enseignante
4. Progr. struct. - C Introduction 4
Organisation de l'enseignement
ME GC
14h cours
14h TD
20h TP
Mini projet & oral
+
Contrôle continu
+
Examen ME
14h cours
20h TD
20h TP
La semaine 51
Projet & oral
+
Contrôle continu
+
Examen GC
Maxime Alarcon
&
Yassine El Khatari
5. Progr. struct. - C Introduction 5
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 :
→ Accès 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)
6. Progr. struct. - C Introduction 6
En pratique : le 1er
TD c'est
• GC 3.1, Mercredi 09/10, 15h30
• GC 3.2, Mercredi 09/10, 13h30
• ME 3.1, Lundi 07/10, 10h
• ME 3.2, Lundi 07/10, 13h30
• ME 3.3, Vendredi 11/10, 10h
• ME 3.4, Mardi 08/10, 13h30
7. Plan du cours
1. Introduction
2. Les bases du langage C
3. Les pointeurs et les tableaux
4. Les fonctions
5. Les types utilisateurs
6. La gestion de fichiers
7. La programmation modulaire
8. L'allocation dynamique de mémoire
9. Les listes chaînées
8. Progr. struct. - C Introduction 8
Les objectifs de ces cours,
TD, TP
• Apprendre à résoudre un problème grâce à un
algorithme,
• Apprendre à programmer en C à des débutants de
manière efficace,
• Initier à la programmation par gestion d'évènements,
• Pratiquer un environnement de développement
largement utilisé dans l'industrie,
• Être une introduction au C++
...
10. Progr. struct. - C Quelques généralités 10
Quelques généralités
en programmation
• Qu'est-ce qu'un Algorithme ?
• Langages de Programmation
• Qu'est-ce qu'un programme ?
• La structure d'un programme
• L'exécution du programme
11. Progr. struct. - C Quelques généralités 11
Qu'est-ce qu'un Algorithme ?
Un algorithme énonce une résolution sous la
forme d’une série d’opérations à effectuer.
ingrédients
Recette de cuisine
plat
données
(entrées)
Algorithme résultat
(sorties)
12. Progr. struct. - C Quelques généralités 12
Conception d'un Algorithme :
Analyse hiérarchisée
C'est faire une liste de tâches (ou d'actions) à
réaliser de manière séquentielle.
Recette du gâteau à la crème de marrons :
1) Préchauffer le four à 180°C
2) Faire fondre le chocolat et le beurre
3) Casser 3 œufs et les battre
4) Ajouter la crème de marrons, et mélanger
5) Incorporer le chocolat fondu à la préparation
6) Beurrer un moule à gâteau et y verser la préparation
8) Faire cuire 35 min à 180°C
13. Progr. struct. - C Quelques généralités 13
Langages de programmation :
Pourquoi faire?
• Pour écrire avec des mots et signes
compréhensibles par une intelligence humaine
plutôt que 00111000111
• Afin d'organiser, de structurer, le déroulement
d'un programme de manière claire et vérifiable.
14. Progr. struct. - C Quelques généralités 14
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
15. Progr. struct. - C Quelques généralités 15
Programme exécutable
Suite d’instructions binaires que le µprocesseur
doit effectuer :
• Spécifiques à un type de µprocesseur.
• Stockées sur une mémoire de masse
(disque dur, DVD, clef usb).
• Chargées en mémoire centrale avant
l’exécution du programme.
16. Progr. struct. - C Quelques généralités 16
Comment réaliser un programme ?
• Éditer le code source : fichier texte qui obéit aux
règles de syntaxe du langage.
• Le sauvegarder de temps en temps.
• Le compiler, le traduire en langage machine pour
obtenir un fichier exécutable.
Fichier
Source
Fichier
Exécutable
Compilation
Fichier
Objet
Éditeur
de liens
17. Progr. struct. - C Quelques généralités 17
L'exécution du programme
Au lancement du programme, le système
d’exploitation :
• Transfère le programme de la mémoire de
masse en mémoire centrale,
• Réserve de la place pour les données du
programme,
• Démarre l’exécution du programme,
• Reprend la main quand le programme s’achève.
18. Progr. struct. - C 1er programme 18
1er
programme en C
• Langage C : histoire et qualités
• LabWindows/CVI
• Le fichier source en C
• On se lance …
19. Progr. struct. - C 1er programme 19
Le langage C
• Crée par K. Thompson, D. Ritchie et B. Kernighan
pour développer UNIX.
• C’est un langage structuré et portable.
• C’est le langage le plus utilisé par les professionnels
du logiciel.
• C’est la base du C++ qui permet la programmation
orientée objet.
20. Progr. struct. - C 1er programme 20
LabWindowsTM
/CVI
• Environnement de Développement Intégré (IDE)
sous Windows, avec 1 compilateur C-ANSI.
• Programmation événementielle
et interface graphique.
• Logiciels de mesure et contrôle
21. Progr. struct. - C 1er programme 21
Premier Programme
en langage C
sous LabWindows/CVI
source_1.c
22. Progr. struct. - C 1er programme 22
Le fichier Source en C
#include <stdio.h>
int main()
{
printf("Bienvenue a POLYTECH Marseille n");
return(0);
}
source_1.c
//Fonction ou bloc principal
// fichier en-tête ou header où
se trouve la définition de printf()
23. Prog. Struct. - C Les bases 23
Les bases du langage C
1. Les types de données
2. Les variables
3. Les opérateurs
4. Les structures conditionnelles
Département Génie Civil & Département Mécanique Énergétique
24. Prog. Struct. - C 1. Les types de données 24
Types, variables et constantes
Qu'est-ce qu'une variable ?
• c'est le nom d’un emplacement mémoire
0001110000110000
• on en crée presque autant qu’on veut
• son contenu peut changer dans le temps.
• elle contient toujours quelque chose !!!
Une variable sera toujours définie avant utilisation :
elle doit être associée à un type de données.
25. Prog. Struct. - C 1. Les types de données 25
Les types de données
1 nombre : entier ou réel
1 pointeur : adresse
1 Variable en C
Qu'est-ce qu'un type ?
• définit une convention de codage de l'information
• dans un emplacement de taille préfixée
26. Prog. Struct. - C 1. Les types de données 26
Les nombres entiers
0 à 4 294 967 295
4
Ent. long non
signé
unsigned long
int
-2 147 483 648 à
2 147 483 647
4
Entier long
long int
0 à 4 294 967 295
4
Entier non signé
unsigned int
-2 147 483 648 à
2 147 483 647
4
Entier
int
0 à 65 535
2
Entier court non
signé
unsigned short
int
-32 768 à 32 767
2
Entier court
short int
0 à 255
1
Caractère non
signé
unsigned char
-128 à 127
1
Caractère
char
Plage de valeurs
Taille (octet)
Signification
Types
prédéfinis
27. Prog. Struct. - C 1. Les types de données 27
Les nombres réels
3,4 10-4932
à 3,4 104932
10
Flottant double
long
long double
1,7 10-308
à 1,7 10308
8
Réel double
précision
double
3,4 x 10-38
à 3,4 x 1038
4
Réel simple précision
float
Plage de valeurs
Taille (octet)
Signification
Types
prédéfinis
29. Prog. Struct. - C 1. Les types de données 29
Les pointeurs
0x0000 à 0xFFFF
0x00000000 à 0xFFFFFFFF
2 (sur 16 bits)
4 (sur 32 bits)
adresse
*pointeur
Plage de valeurs
Taille (octet)
Signification
Type
30. Prog. Struct. - C 2. Les variables 30
Les variables
Leur nom :
• Contient 32 caractères max
• Commence par une lettre
• Ne peut être un des mots réservés du C
volatile
struct
register
float
default
auto
while
switch
return
for
do
break
typedef
short
goto
double
case
union
signed
if
else
char
static
sizeof
void
unsigned
long
extern
continue
int
enum
const
31. Prog. Struct. - C 2. Les variables 31
Les variables : leurs noms
identificateur
nom réservé
goto
_707
signe - interdit
Nom-de-variable
nom_de_variable_123
caractère spécial @
toto@mailcity.com
nom_de_variable
commence par un
chiffre
123Nom_De_Variable
Nom_De_Variable
comporte des espaces
Nom de Variable
Variable
Raison
incorrect
Correct
MAJUSCULE ≠ minuscule
32. Prog. Struct. - C 2. Les variables 32
type nom_de_la_variable ;
exemple :
#include <stdio.h>
int main()
{
int a; //déclaration
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);
}
La déclaration de variables
33. Prog. Struct. - C 2. Les variables 33
#include <stdio.h>
int main()
{ float a;
a = douze*PI;
}
Les constantes
//Directive du pré processeur
#define PI 3.14159
//Déclaration d'une constante
const int douze=12;
34. Prog. Struct. - C 2. Les variables 34
• Afficher à l'écran une variable
int Nb_vies=3;
printf("Pour afficher à l' écrann");
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 float → %f
int → %d double → %lf
Ce que vous allez faire le + souvent :
35. Prog. Struct. - C 3. Les opérateurs 35
Les opérateurs du C
• les opérateurs de calcul
• …………………… d'assignation
• …………………… d'incrémentation
• …………………… de comparaison
• …………………… logiques
• …………………… bit-à-bit
• …………………… de décalage de bit
• Les priorités
36. Prog. Struct. - C 3. Les opérateurs 36
Les opérateurs de calcul
Met la valeur 3
dans la variable x
3
30
7
13
Si
int x=10;
Met la valeur 3.00
dans la variable x
x=3;
d'affectation
=
3.3333333
x=x/3;
de division
/
30.0
x=x*3;
de multiplication
*
7.0
x=x-3;
de soustraction
-
13.0
x=x+3;
d'addition
+
Si
float x=10.0;
Exemple
Opérateur
=
% modulo x=x%3; 1 ← reste de la division
37. Prog. Struct. - C 3. Les opérateurs 37
Les opérateurs d'assignations
divise deux valeurs et stocke le résultat dans la variable
/=
multiplie deux valeurs et stocke le résultat dans la variable
*=
soustrait deux valeurs et stocke le résultat dans la variable
-=
additionne deux valeurs et stocke le résultat dans la
variable (à gauche) x
+=
x=x+2; peut aussi s'écrire x+=2;
x=a=b=3; ⇔ x= (a= (b=3));
38. Prog. Struct. - C 3. Les opérateurs 38
Les opérateurs d'incrémentation
ce sont les + utilisés
• ++ : incrémentation de 1
x=3;
//post-incrémentation
y=x++; ⇔ y=x; x=x+1; //y=3, x=4
//pré incrémentation
y=++x; ⇔ x=x+1; y=x; //x=y=5
• -- : décrémentation de 1
y=x--; ⇔ y=x; x=x-1; //y=5, x=4
39. Prog. Struct. - C 3. Les opérateurs 39
Les opérateurs de comparaison
utilisés lors de tests
Retourne 1 si x est différent de
3, sinon 0
x!=3
différence
!=
Retourne 1 si x est supérieur
ou égal à 3, sinon 0
x>=3
supériorité
>=
Retourne 1 si x est supérieur à
3, sinon 0
x>3
supériorité
stricte
>
Retourne 1 si x est inférieur ou
égal à 3, sinon 0
x<=3
infériorité
<=
Retourne 1 si x est inférieur à
3, sinon 0
x<3
infériorité stricte
<
Retourne 1 si x est égal à 3,
sinon 0
x==3
égalité
==
Résultat si x vaut 7
Exemple
Opérateur
40. Prog. Struct. - C 3. Les opérateurs 40
Les opérateurs bit-à-bit
5
9 ^ 12
OU exclusif
^
13
9 | 12
OU
|
8
9 & 12
ET
&
Résultat
Syntaxe
Opérateur
1001
& 1100
1000
1001
| 1100
1101
1001
^ 1100
0101
41. Prog. Struct. - C 3. Les opérateurs 41
Les opérateurs de décalage de bit
3
6 >> 1
/2
Décalage à droite avec
conservation du signe
>>
12
6 << 1
x 2
Décalage à gauche
<<
Résultat
Syntaxe
Opérateur
00000110 << 1
= 00001100
11111010 >> 1
= 11111101
00000110 >> 1
= 00000011
En signé : -6 <<1 = -12
-6 >>1 = -3
11111010 << 1
= 11110100
43. Prog. Struct. - C 4. Les structures conditionnelles 43
4 types d'instructions
• Nulle ;
• Expression a=b+1;
• Prédéfinie condition ou boucle if ()
• Bloc { }
44. Prog. Struct. - C 4. Les structures conditionnelles 44
Les structures conditionnelles
• Les instructions de branchement conditionnel
if(condition)
if(condition)… else
switch(variable) case
• Les instructions de boucle
while(condition)
do … while(condition);
for(initialisation;condition;incrementation)
si (vrai) alors …
sinon ...
45. Prog. Struct. - C 4. Les structures conditionnelles 45
L'instruction if
• syntaxe :
if(condition)
{
instructions;
}
condition
instructions
VRAI
FAUX
47. Prog. Struct. - C 4. Les instructions conditionnelles 47
L'instruction if…else
• Exemple :
if (var1==0) //si var1 vaut 0
{ //alors on affiche
printf("La variable est nullen");
}
else //sinon c'est faux
{
if (var1 > 0)
printf("Elle est positiven");
else
printf("Elle est négative");
}
{ }
{ }
48. Prog. Struct. - C 4. Les instructions conditionnelles 48
Attention aux forêts d'if()
• exemple :
if (var1!=0)
if (var1 > 0)
printf("Elle est positiven");
else
printf("Elle est négativen");
else se rapporte toujours au if le plus proche
49. Prog. Struct. - C 4. Les instructions conditionnelles 49
L'opérateur conditionnel
(condition) ? instruction_vrai : instruct_faux
• exemple :
x = 3;
y = 2;
max_xy = ((x>=y) ? x : y);
=
1
max_xy = x;
50. Prog. Struct. - C 3. Les opérateurs 50
Pour faire plusieurs tests à la fois : les
opérateurs conditionnels logiques
(!condition)
((cond1)&&(cond2))
((cond1)||(cond2))
Syntaxe
NON logique
!
ET logique
&&
OU logique
||
Opérateur
!a
a&&b
a||b
b
a
0
0
1
1
1
0
0
0
1
1
1
1
0
1
1
1
0
0
0
0
51. Prog. Struct. - C 4. Les instructions conditionnelles 51
L'instruction de choix multiples :
switch
• Syntaxe :
switch (expr)
{ case const1:
instructions;
break;
case const2:
instructions;
break;
default:
instructions;
break;
}
==const1
V
F
instr.
?
==const2
V
F
?
instr.
V
instr.
!=const1,2
?
52. Prog. Struct. - C 4. Les instructions conditionnelles 52
switch
• exemple :
char choix;
printf("Taper 1 ou 2");
scanf("%c",&choix);
switch(choix)
{ case '1':
printf("vous avez tape 1n");
break;
case '2':
printf("vous avez tape 2n");
break;
default :
printf("je vous ai dit 1 ou 2 pas %cn",choix);
break;
}
53. Prog. Struct. - C 4. Les instructions conditionnelles 53
Les instructions de boucle :
pour répéter les
mêmes instructions
plusieurs fois
54. Prog. Struct. - C 4. Les instructions conditionnelles 54
L'instruction while
• tant que (condition vraie)
• syntaxe :
while(condition)
{
instructions;
}
condition
VRAI
FAUX
instructions
55. Prog. Struct. - C 4. Les instructions conditionnelles 55
L'instruction do…while
• faire … tant que (condition vraie)
• syntaxe :
do
{
instructions;
}while(condition);
condition
VRAI FAUX
instructions
56. Prog. Struct. - C 4. Les instructions conditionnelles 56
L'instruction for()
• syntaxe :
for( init;condition;incrément)
{
instructions;
}
• exemple :
for(i=0;i<100;i++)
{
printf("%dn",i);
}
initialisation du
compteur de boucle
condition
instructions
VRAI
FAUX
modification du
compteur de boucle
57. Prog. Struct. - C 4. Les instructions conditionnelles 57
Attention aux boucles sans fin
•exemple :
for( ; ; )
{
printf("sans finn");
}
;
1
Affichage
"sans fin"
V
F
;
58. Prog. Struct. - C 4. Les instructions conditionnelles 58
Les instructions de sortie :
pourquoi sont-elles utiles ?
• exemple :
x=1;
while(x<=10)
{
a=1/(x-7);
printf("%f",a);
x++;
}
x=1
x=x+1
affichage a
a=1/(x-7)
x <= 10
?
V
F
Que va-t-il se passer quand
x=7 ?
59. Prog. Struct. - C 4. Les instructions conditionnelles 59
x=1
x <= 10
?
V
F
x ==7
?
V
F
affiche /0
x=x+1
a=1/(x-7)
affichage de a
x=x+1
Les instructions de sortie :
continue
• exemple :
x=1;
while(x<=10)
{
if (x==7)
{ printf("division par 0");
x++;
continue;
}
a=1/(x-7);
printf("%f",a);
x++;
}
60. Prog. Struct. - C 4. Les instructions conditionnelles 60
Les instructions de sortie :
break
• exemple :
x=1;
while(x<=10)
{
a = x-7;
printf("%f", 1/a);
x++;
}
x=1
x=x+1
affichage 1/a
a=x-7
x <=10
?
V
F
Que va-t-il se passer quand
x=7 ?
61. Prog. Struct. - C 4. Les instructions conditionnelles 61
Les instructions de sortie :
break
• exemple :
x=1;
while(x<=10)
{
a = x-7;
if (a == 0)
{
printf("/ par 0");
break;
}
printf("%f", 1/a);
x++;
}
x=1
x=x+1
affichage 1/a
a=x-7
x <=10
?
V
F
F
a == 0
?
V
affiche /0
62. Prog. Struct. - C 4. Les instructions conditionnelles 62
Les instructions de sortie :
return
• syntaxe :
return(expression);
• exemple :
int main()
{
…
return(0);
}
63. Exemples
– Résolution numérique d'une équation du second
degré
– Programme mystère
– Affectation et récurrence
Département Génie Civil & Département Mécanique Énergétique
64. Prog. Struct. C 5. Ex : équation du 2nd degré 64
Résolution de ax2
+bx+c=0 :
Organisation du programme
Initialisation :
Acquisition au clavier
des valeurs de a,b,c
Algorithme de calcul
Présentation des
résultats sur l’écran
65. Prog. Struct. C 5. Ex : équation du 2nd degré 65
Soit a,b,c,D, x1 et x2 des réels
Lire les coefficients a, b, c
si1
a est égal 0
Alors1
Afficher "trop facile C pas du 2nd
degré"
sinon1
D b*b - 4 a*c
si2
D est inférieur à 0
alors2
Afficher "pas de racines réelles"
sinon2
si3
D est égal à 0
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
66. Prog. Struct. C 5. Ex : équation du 2nd degré 66
Résolution de ax2
+bx+c=0 : Organigramme
Acquisition de a, b, c
a= = 0
fin
VRAI
Calcul de D
FAUX
D < 0
Pas de racines
V
D==0
Racine
double
F
V
2 Racines
distinctes
F
Affichage C
pas 2° degré
67. Prog. Struct. C 5. Ex : équation du 2nd degré 67
Le squelette
#include <stdio.h>
#include <math.h>
int main()
{
/*Déclaration de variables a,b,c,delta,x1,x2*/
/*Entrée 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 réelles
}
Directives du pré processeur
68. Prog. Struct. C 5. Ex : équation du 2nd degré 68
II
Fonction main ()
int main()
{
/*Déclaration de variables */
float a,b,c;
float delta;
float x1,x2;
/*Fin de la déclaration des variables*/
69. Prog. Struct. C 5. Ex : équation du 2nd degré 69
Fonction main () … suite
/*Entrée/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*/
70. Prog. Struct. C 5. Ex : équation du 2nd degré 70
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*/
71. Prog. Struct. C 5. Ex : équation du 2nd degré 71
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
72. Prog. Struct. C 5. Ex : équation du 2nd degré 72
Algorithme
mystérieux
Soit a, b, r réels ;
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;
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);
}
73. Prog. Struct. C 5. Ex : équation du 2nd degré 73
Récurrence
• Mathématiquement une relation de
récurrence, c'est :
xi+1 = f(xi) avec x0 donné
permet de déterminer toutes les valeurs des
termes de la suite xk.
• La valeur d'un nouveau terme se déduit à
partir de celle du précédent.
74. Prog. Struct. C 5. Ex : équation du 2nd degré 74
Affectation
x = expression(x);
x x + 3;
Le nouveau contenu de x (après l'exécution de
l'instruction) est le résultat de l'évaluation de
l'expression avec le contenu actuel de x.
75. Prog. Struct. C 5. Ex : équation du 2nd degré 75
Exemple : Calculer
( )
∑=
+
−
=
n
i
i
n
i
S
1
1
1
Ce qui donne la relation de récurrence :
( )
k
S
S
k
k
k
1
1
1
+
−
−
+
=
Avec 1
1 =
S
recurrence.c
76. Prog. struct. : C III-Les pointeurs et les tableaux 76
Les pointeurs et les tableaux
1. Les pointeurs
2. Les tableaux
• Les chaînes de caractères
• Les tableaux à plusieurs indices
Département Génie Civil & Département Mécanique Énergétique
77. Prog. struct. : C III-Les pointeurs ... 77
Les pointeurs : définition
Un pointeur est une variable qui contient
l'adresse d'une autre variable :
• d’une donnée,
• d’une fonction (fera l'objet du prochain cours).
78. Prog. struct. : C III-Les pointeurs ... 78
Les pointeurs sur donnée
a) Déclaration d’un pointeur sur donnée
b) Mécanisme de l'adressage indirect
c) Arithmétique des pointeurs
79. Prog. struct. : C III-Les pointeurs ... 79
Déclaration d’un pointeur sur donnée
• La déclaration :
Type_donnee *Ident_ptr;
• Exemple :
int *pAdi;
pAdi est codé sur 4 octets (adressage 32 bits) et contiendra
l'adresse d'un entier
80. Prog. struct. : C III-Les pointeurs ... 80
Mémoire, adresse et pointeur
http://www.siteduzero.com/
81. Prog. struct. : C III-Les pointeurs ... 81
L’adressage indirect
int i,*pAdi; 10 Adresse de i
Adresse de i Adresse de pAdi
i
pAdi
contenu contenant
contenant
i=10;
pAdi = &i;
*pAdi = 12;
contenu
82. Prog. struct. : C III-Les pointeurs ... 82
L’adressage indirect
int i,*pAdi;
Adresse de i
Adresse de i Adresse de pAdi
i
pAdi
contenu contenant
i=10;
pAdi = &i;
*pAdi = 12;
12
contenu contenant
83. Prog. struct. : C III-Les pointeurs ... 83
& et *
int i;
int *padi;
& pour accéder à l'adresse d'une donnée
ex : &i le numéro de la case mémoire
correspondant à la variable i padi = &i;
* pour accéder au contenu d'une adresse
ex : *padi permet d'accéder au contenu de
l'adresse padi contenu de l'adresse de i i
84. Prog. struct. : C III-Les pointeurs ... 84
Arithmétique des pointeurs
sur données
• Additions et soustractions d'entiers sur les
adresses contenues dans les pointeurs
• Elles les déplacent de la quantité, qui a été
additionnée ou soustraite, multipliée par la
taille en octet du type de l'objet pointé.
85. Prog. struct. : C III-Les pointeurs ... 85
Exemple :
int i = 80;
double xx=3.1415;
double *pAd;
…
pAd = &xx;
pAd = pAd+i;
/*pAd +i*sizeof(double)
c.a.d. 64 + 80*8 octets*/
60 80 i
64 3.1415 xx
100 ? pAd
contenant contenu nom
60 80 i
64 3.1415 xx
100 64 pAd
60 80 i
64 3.1415 xx
100 704 pAd
86. Prog. struct. : C III- ... Les tableaux 86
Les Tableaux
1. Les tableaux mono-dimensionnels
2. Les chaînes de caractères
3. Les tableaux de tableaux …
87. Prog. struct. : C III- ... Les tableaux 87
Qu'est-ce qu'un tableau ?
C'est une suite de variables de même type, rangées
dans un espace contigu de la mémoire.
88. Prog. struct. : C III- ... Les tableaux 88
Les Tableaux : déclaration et définition
Type_donnee Ident_Tab [NbElem];
• int, double, char …
• NbElem le nbre d’éléments du tableau
constante littérale ou symbolique (#define)
• Ident_Tab le nom du tableau le pointeur
sur le tableau contient l'adresse du 1er
élément
du tableau
89. Prog. struct. : C III- ... Les tableaux 89
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
90. Prog. struct. : C III- ... Les tableaux 90
Tableaux à un seul indice et Pointeur
Tab[0] Tab[1] Tab[2] … Tab[N-1]
Tab+i &Tab[i]
Tab [i]
*(Tab+i)
pointeur tableau
int Tab[N];
printf("%d",*Tab); ou printf("%d",Tab[0]);
scanf("%d",Tab+2); ou scanf("%d",&Tab[2]);
91. Prog. struct. : C III- ... Les tableaux 91
Exemple : Saisir et afficher
les éléments d'un tableau
Mon premier tableau
92. Prog. struct. : C III- ... Les tableaux 92
Exemple de Tableau 1D :
Les chaînes de caractères (string)
• Déclaration 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
93. Prog. struct. : C III- ... Les tableaux 93
Chaînes de caractères
char *pfin;
char cBonjour [] = "Bonjour";
printf("%sn", cBonjour);
pfin = cBonjour + 3;
printf("%sn", pfin);
pfin = cBonjour+strlen(cBonjour);
do
{
printf ("%c",*--pfin);
}while (pfin != cBonjour);
95. Prog. struct. : C III- ... Les tableaux 95
Pour comprendre
'o'
'B' 'n' 'j' 'o' 'u' 'r' Ø
cBonjour pfin
strlen(cBonjour) renvoie 7
Adresse pointée par pfin ← Adresse pointée par cBonjour+7
96. Prog. struct. : C III- ... Les tableaux 96
Chaîne de Caractères
Exemple
!OG
97. Prog. Struct. - C III - ... Les tableaux 97
Tableau de Tableaux
• Déclaration :
Type_donne Indent_Tab_Tab[Nlign][Ncol];
Nlign et Ncol sont des constantes entières littérales
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]);
98. Prog. Struct. - C III - ... Les tableaux 98
Tableau à deux indices
...
NCol NCol NCol
NLign x NCol
Ligne0 Ligne1
99. Prog. Struct. - C III - ... Les tableaux 99
Tableau à 2 indices et Pointeurs
Tab[i] ⇔ &Tab[i][0]
Tab[i] est un pointeur constant sur un tableau de nCol
éléments
Tab est un pointeur constant sur un tableau d’adresses
de tableaux de nCol éléments
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
100. Prog. Struct. - C IV - Les Fonctions 100
Les fonctions
1. Introduction
2. Mise en œuvre
3. Passage par valeur et par adresse
4. Pour aller plus loin
Département Génie Civil & Département Mécanique Énergétique
101. Prog. Struct. - C IV - Les Fonctions 101
Jusqu'à maintenant, vos programmes
ressemblent à ça...
#include <stdio.h>
#define N 10
int main()
{ int i;
float TAB[N];
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;
}
Directives au pré-processeur
La fonction principale
Il ne peut y en avoir qu'une !!
102. Prog. Struct. - C IV - Les Fonctions 102
Introduction
Une fonction vue par un débutant
Fonction
=
brique
Entrée Sortie
C'est un morceau de programme qui sert à faire
quelque chose de précis.
Le but : simplifier le code source, pour ne pas avoir à
réécrire le même code plusieurs fois.
103. Prog. Struct. - C IV - Les Fonctions 103
Introduction
Une fonction vue du processeur
• C'est un code exécutable terminé par une
instruction de retour situé à une certaine adresse
en mémoire.
• À l'appel de la fonction, le processeur exécute le
code à partir de l'adresse de la fonction et
l'instruction retour le fait revenir à l'instruction
suivant l'appel.
• Des données peuvent être transmises à la fonction
en paramètres. Lors du retour, une valeur peut être
récupérée/renvoyée.
104. Prog. Struct. - C IV - Les Fonctions 104
Instruction i ;
Appel MaFonction() ;
Instruction i+2 ;
Ligne n°1 de MaFonction()
La suite de MaFonction()
Instruction return();
MaFonction
Adresse
105. Prog. Struct. - C IV - Les Fonctions 105
if (argument>0)
Le calcul de sqrt(4)
Retour de 2
sqrt(argument)
Exemple avec la fonction sqrt() :
4
Adresse
return(2)
Instruction i ;
X = sqrt(4) ;
Instruction i+2 ;
106. Prog. Struct. - C IV - Les Fonctions 106
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 réalisent chacune une partie de la
tâche.
Un programme est un ensemble de fonctions,
qui s'exécute à partir de la fonction main ()
• Un programmeur professionnel utilise des
bibliothèques de fonctions pour accélérer le
développement de son application.
107. Prog. Struct. - C IV - Les Fonctions 107
Instruction i;
MaFonction(10,x+y,z);
MaFonction {
Instructions
De MaFonction
…
return;
}
Instruction_suiv;
Passage de
paramètres
10
x+y
z
108. Prog. Struct. - C IV - Les Fonctions 108
Fonction : Mise en œuvre
#include <stdio.h>
/* 2) Le prototypage */
int main()
{
…
/* 3) L'appel */
…
}
/* 1) La définition */
109. Prog. Struct. - C IV - Les Fonctions 109
1) La Définition
Localisation : #include <stdio.h>
int main()
{
…
}
//Définition des fonctions
Exemples de fonctions :
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;
}
Arguments ou
paramètres
110. Prog. Struct. - C IV - Les Fonctions 110
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()
{
…
}
111. Prog. Struct. - C IV - Les Fonctions 111
3) L'appel de la fonction
{
double ValDisc;
…
ValDisc = CalcDisc (a,b,c);
…
}
Paramètres de la fonction
Où fait-on appel à la fonction ?
Dans n'importe quelle définition de fonction, par ex.
dans la fonction main(), y compris dans sa propre
définition → Récursivité
112. Prog. Struct. - C IV - Les Fonctions 112
Ma première fonction
fonctionsexemple1.prj
113. Prog. Struct. - C IV - Les Fonctions 113
2 types de fonctions
1) Celles qui ne retournent rien (void).
Elles sont également appelées procédures.
void nom_fonction(déclarations_d'arguments)
EXEMPLE : /* Procédure affichant le produit de deux entiers */
/* Paramètres d'entrée : 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);
}
114. Prog. Struct. - C IV - Les Fonctions 114
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 */
/* Paramètres d'entrée : deux entiers, Type retour : entier */
int calcule_produit (int iExp1, int iExp2)
{
int iProduit;
iProduit = iExp1 * iExp2;
return iProduit;
}
115. Prog. Struct. - C IV - Les Fonctions 115
2 types d'arguments :
1) ceux passés par valeur
//Prototypage
void fonction1(double z);
//Définition
void fonction1(double z)
{
z = z * 2.0;
printf("z = %lfn",z);
}
On donne le code de la
fonction. Le compilateur
réserve 8 octets de la pile
désignés par z. Pour le
moment, le contenu de cette
zone est indéterminé.
On indique au compilateur
que fonction1 est une
fonction qui ne retourne
rien et qui admet pour
paramètre un double
Lors de l'appel de la fonction, le
contenu de la zone repérée par z
sera x 2
116. Prog. Struct. - C IV - Les Fonctions 116
Exécution : Appel de la fonction
/*A l'intérieur de la
fonction appelante par
exemple le main()*/
double x = 20.0;
...
fonction1 (x);
pile
Zone de 8 octets
réservée pour z
20.0
Zone de 8 octets
réservée pour x 20.0
117. Prog. Struct. - C IV - Les Fonctions 117
Lors de l’exécution
Zone de 8 octets
réservée pour z
20.0
40.0
pile
Zone de 8 octets
réservée pour x
Hors de portée
de fonction1
20.0
void fonction1 (double z)
{
z = z*2.0;
}
118. Prog. Struct. - C IV - Les Fonctions 118
Après l’exécution d'une fonction où les
paramètres sont passés par valeur
Zone de 8 octets
réservée pour x de
nouveau accessible
20.0
La zone mémoire réservée pour z n’est plus
accessible,
et le contenu de x n’a pas été modifié !
119. Prog. Struct. - C IV - Les Fonctions 119
//Prototypage
void fonction2(double *pz);
//Définition
void fonction2 (double *pz)
{
*pz = (*pz)*2.0;
}
4 octets désignés par pz
sont réservés dans la
pile.
On indique au compilateur que :
- fonction2 ne retourne rien,
- et admet pour paramètre un pointeur sur double
Ce qui est pointé par pz sera x 2 lors de l'appel de la fonction.
2 types d'arguments :
2) ceux passés par adresse
120. Prog. Struct. - C IV - Les Fonctions 120
pile
4 octets
réservés
par pz
& x
Zone de
8 octets
réservée
par x
20.0
Exécution :
Appel de la fonction
//A l'intérieur de la
fonction appelante
double x = 20.0;
...
fonction2 (&x);
121. Prog. Struct. - C IV - Les Fonctions 121
4 octets réservés pour pz
pile
x inaccessible dans fonction2,
mais atteint grâce à l'adressage
indirect
40.0
void fonction2 (double *pz)
{
*pz =(*pz)*2.0;
}
& x
Au sein de la fonction
20.0
122. Prog. Struct. - C IV - Les Fonctions 122
Après l’exécution
pile
8 octets
réservés pour x de
nouveau accessible
40.0
La zone mémoire réservée pour pz
n’est plus accessible
et le contenu de x a été modifié par
adressage indirect !
123. Prog. Struct. - C IV - Les Fonctions 123
Exemple
val_et_adr.prj
Ma deuxième fonction
124. Prog. Struct. - C IV - Les Fonctions 124
Rappels sur les fonctions
• 3 étapes pour la mise en œuvre : le prototypage,
la définition, et l'appel.
Les arguments/paramètres : constante, variable,
expression, fonction
• Si pas void alors return à la fin de la définition
• Le passage des arguments peut se faire par
valeur, ou par adresse lorsqu'on souhaite
modifier la variable passée en argument.
125. Prog. Struct. - C IV - Les Fonctions 125
Squelette d'un programme
Zone des directives de préprocesseur
#include …
#define …
Déclaration des variables de portée fichier
Prototypage des fonctions
Définition de la fonction main()
int main()
{
}
Définition de vos fonctions
Que se cache-t-il dans stdio.h ?
126. Prog. Struct. - C IV - Les Fonctions 126
A RETENIR !!!
• Pour modifier le contenu d'une variable
déclarée dans la fonction appelante par la
fonction appelée, il est nécessaire de passer en
paramètre l'adresse de cette variable.
• Donc, dans le prototypage et la définition de la
fonction, l'argument doit être un pointeur.
!
127. Prog. Struct. - C IV - Les Fonctions 127
Pour aller plus loin
1. La récursivité
2. La portée des variables : locales ou globales
3. Les tableaux comme arguments
4. Les pointeurs sur fonctions
128. Prog. Struct. - C IV - Les Fonctions 128
1) La Récursivité :
La fonction s'appelle elle-même !
• Exemple :
double Factorielle (int n); //Prototype
double Factorielle (int n)
{
if (n <= 0)
return 1;
return n*Factorielle (n-1);
}
Condition d'arrêt
Appel récursif
factorielle.prj
129. Prog. Struct. - C IV - Les Fonctions 129
2) La portée des variables
• Les variables locales sont temporaires. Elles
sont déclarées au sein de fonctions.
• Les variables globales sont permanentes. Elles
sont déclarées en en-tête du programme.
varlife.prj
Attention à ne pas toutes
les appeler n, i ou j!!!
130. Prog. Struct. - C IV - Les Fonctions 130
3) Tableaux passés en
paramètres à 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);
131. Prog. Struct. - C IV - Les Fonctions 131
• 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);
3) Tableaux passés en
paramètres à une fonction
132. Prog. Struct. - C IV - Les Fonctions 132
4) Les Pointeurs sur fonction
• Déclaration
• Affectation
• Utilisation
133. Prog. Struct. - C IV - Les Fonctions 133
Déclaration d'un pointeur sur
fonction
Type_Val_Ret(*Ident_ptr_Fonc)(Signature_fonc);
Signature_fonc
Liste ordonnée des types des
arguments de la fonction sans
les identificateurs des
arguments
Exemple
double (*pFonc)(double);
pFonc est un pointeur sur une
fonction retournant un double et
admettant un double en
argument.
134. Prog. Struct. - C IV - Les Fonctions 134
Initialisation, Affectation d'un
pointeur sur fonction
double (*pFonc)(double);
Nécessite
#include <math.h>
Le prototype de MaFonc doit être connu par le
compilateur.
double (*pTabFonc [3])(double)={sin,cos,tan};
pFonc = MaFonc;
135. Prog. Struct. - C IV - Les Fonctions 135
pointfonct.prj
Pointeurs sur fonction
136. Prog. struct. C
Les types utilisateurs
1. Les structures
2. Les unions
3. Les énumérations
http://iusti.polytech.univ-mrs.fr/~bergougnoux/enseignement.htm
Département Génie Civil & Département Mécanique Énergétique
137. Prog. struct. C V- Les structures 137
Les types utilisateurs
servent à créer ses
propres types de variables
Pour manipuler :
- des nombres complexes,
- des cordonnées (x,y,z) de points,
- des images,
....
- un ensemble de variables qui peuvent être de type ≠
138. Prog. struct. C V- Les structures 138
De la fiche à la structure
• Pour gérer une clientèle, une bibliothèque, un stock de
pièces détachées, etc…
on a besoin d'informations sur chacun des éléments de
l'ensemble.
• Ces informations sont consignées dans des fiches qui
sont remplies grâce à un formulaire unique.
• C'est le formulaire qui structure les informations
contenues dans les fiches.
139. Prog. struct. C V- Les structures 139
La fiche d'un élève Polytech
Nom : Prénom :
Adresse :
Département Polytech :
Année :
Spécialité :
Login : Password :
Email :
PIGNON François
12 place du marché 13013 Marseille
MT
3
aucune
PIGNMT12 juste12
Francois.Pignon@polytech.univ-mrs.fr
140. Prog. struct. C V- Les structures 140
Traduction Informatique
• Formulaire • Type de donnée
Structure struct
• Fiche
• Fichier
• Variable de type
struct
• Tableau ou liste de
variables de type
struct
modèle
objet
Ensemble
d'objets
141. Prog. struct. C V- Les structures 141
Déclaration du nouveau type
de donnée
• Syntaxe :
struct nom_struct
{
type_1 ident_champ1;
type_2 ident_champ2,ident_champ3;
…
type_N ident_champM;
}nom_var1, ... ,nom_varP;
142. Prog. struct. C V- Les structures 142
Déclaration du nouveau type
de donnée
• Localisation : Après les include
#include <stdio.h>
struct nom_struct
{
type_1 ident_champ1;
type_2 ident_champ2,ident_champ3;
};
//Les prototypes des fonctions
int main()
{
…
}
143. Prog. struct. C V- Les structures 143
Exemple 1 : Définition du type POLYTECH
struct POLYTECH
{
char Nom[80];
char Prenom[80];
char Adresse[200];
int Depart;
int Annee;
int Spec;
char Login[10];
char Passw[8];
char Email[30];
};
9 champs avec des
identificateurs ≠ pas
contigus mais à la suite
144. Prog. struct. C V- Les structures 144
Déclaration d'une donnée
• Syntaxe :
struct nom_struct nom_var;
• Exemple :
struct POLYTECH UnEleve; //variable
struct POLYTECH TabElev[250]; //tableau
struct POLYTECH *pElev; //pointeur
145. Prog. struct. C V- Les structures 145
Accès aux champs de la donnée
• 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;
⇔
146. Prog. struct. C V- Les structures 146
Ex 1 : accès aux champs de POLYTECH
int main()
{
struct POLYTECH TabElev[250];
struct POLYTECH UnEleve;
…
printf("nNom de l'élève :");
scanf ("%s",UnEleve.Nom);
…
TabElev[10] = UnEleve;
(TabElev+10)->Annee = 1;
}
147. Prog. struct. C V- Les structures 147
Exemple 1 :Utilisation suite
• Arguments et paramètres 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
148. Prog. struct. C V- Les structures 148
Définition de type composé
struct tComplex
{
double Re;
double Im;
};
Structure nommée
typedef struct tComplex Complex;
définition d'un nouveau type
ce nouveau type suit le
modèle struct tComplex
Le nom de ce nouveau
type est Complex
149. Prog. struct. C V- Les structures 149
Complex zI = {0,1.0};
…
Complex *pz;
Complex zTabVal [10];
pz = &zI;
pz->Re = sqrt(2)/2;
pz->Im = pz->Re;
zTabVal[0].Re = 11.5;
(zTabVal+5)->Im = sqrt(2);
Exemple 2 : Représentation des
nombres complexes
Déclarations des variables
zI, pz et zTabVal de type
Complex
Utilisation de ces
variables
150. Prog. struct. C V- ... Les unions 150
Union
Ensemble de variables de type différents pouvant
alternativement occuper la même zone mémoire.
• Syntaxe de déclaration :
la même que pour une structure ...
union jour
{ char lettre;
int numero;
};
• Le stockage en mémoire : tous les champs de l'union
commencent à la même adresse. La taille de l'union est
donc celle du plus grand champ. → On peut donc atteindre
une même zone mémoire de plusieurs façons.
151. Prog. struct. C V-... les énumérations 151
Énumération
Permet de définir 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};
152. Prog. struct. C V- Les structures 152
Exemple
enum tdepart{GC,GII,ME,MT};
typedef enum tdepart DEPART;
…
POLYTECH *pElev;
… /*Mettre une adresse valide dans pElev*/
pElev->Depart = MT;
…
153. La gestion de fichiers
1. Les Flots
2. Ouverture / Fermeture d'un fichier
3. Lecture / Écriture dans un fichier
4. Formats
Département Génie Civil & Département Mécanique Énergétique
154. Prog. struct. C VI- La gestion de fichiers 154
1 Fichier sur 1 Disque
• Chemin d'accès "path" :
C:RepertoireSousRep1...SousRepNNom.ext
• Le mode d'accès
• Les éventuels attributs de protection.
Unité logique
Structure arborescente de
répertoire, sous répertoires, …
Nom du Fichier
et son extension
155. Prog. struct. C VI- La gestion de fichiers 155
Gestion de Fichiers
pour le programmeur
• Transférer une ou des informations d'une
source vers une destination.
• Donc gérer un flot d'informations.
156. Prog. struct. C VI- La gestion de fichiers 156
Flot d’informations
Source :
• Mémoire
de masse
• Clavier
• Port Série
• Mémoire
• Carte SD
• ...
Destination :
• Mémoire de
masse
• Console
• Port Série
• Mémoire
• Carte SD
• ...
Flot / stream
Flot / stream
octets
157. Prog. struct. C VI- La gestion de fichiers 157
La direction du Flot
• Dans la gestion d'un flot, au moins l'une des
destinations est la mémoire de l'ordinateur.
• Pour écrire dans le fichier des informations
stockées dans la mémoire, il faut accèder au
fichier en écriture.
Le flot est en sortie.
• Pour lire les informations du fichier et les stocker
dans la mémoire, on accède au fichier en lecture.
Le flot est en entrée.
158. Prog. struct. C VI- La gestion de fichiers 158
<stdio.h>
standard input output
C'est là qu'est définie la structure FILE !
159. Prog. struct. C VI- La gestion de fichiers 159
Ouverture/Fermeture
de flots en C (ANSI)
• Pour toutes les fonctions de gestion des
flots, il faut un pointeur sur la structure FILE
définie dans stdio.h.
• Le flot est ouvert en appelant fopen() qui
affecte une valeur à cette variable pointeur.
Le flot est fermé par fclose().
160. Prog. struct. C VI- La gestion de fichiers 160
Les flots/fichiers peuvent être ouverts en mode :
• Lecture "r" → la destination existe
"r+" → possibilité d'écriture
• Ecriture "w" → la destination est créée 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").
Les Modes d'ouverture
161. Prog. struct. C VI- La gestion de fichiers 161
• Création, ouverture d'un fichier
FILE *fopen(const char *nom,const char *mode)
• Fermeture d'un fichier
FILE *fclose(FILE *stream)
• Création d'un fichier temporaire
FILE *tmpfile(void)
• Test de fin d'un fichier
int feof(FILE *stream)
Les Fonctions générales
162. Prog. struct. C VI- La gestion de fichiers 162
#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);
}
Exemple
texte_bin.prj
163. Prog. struct. C VI- La gestion de fichiers 163
Les Flots prédéfinis
3 pointeurs sur structure FILE sont gérés
par le système d'exploitation :
•stdin gère les informations envoyées par
le clavier (entrée).
•stdout gère les informations dirigées vers
l'écran (sortie).
•stderr dirige les informations générées par
les erreurs vers un périphérique de sortie.
164. Prog. struct. C VI- La gestion de fichiers 164
#include <stdio.h>
int main()
{
fprintf(stdout,"1ere alternative à printf()n");
fputs("n En voila une autre",stdout);
}
Exemple
ecran.prj
165. Prog. struct. C VI- La gestion de fichiers 165
Écriture dans un fichier
• Ecriture au format texte :
int fprintf(FILE *pfile,const char *format,…)
/* écrit la chaîne formatée dans le fichier, retourne le nbre de
caractères écrits, ou un nombre <0 si erreur */
int fputc(int caractere,FILE *pfile)
/* écrit le caractère dans le fichier, le caractère écrit est retourné,
EOF sinon */
int fputs(const char *s,FILE *pfile)
/* la chaîne 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 indiquée, les uns à la suite
des autres à l'adresse indiquée par source. Renvoie le nombre d'objets
écrits, qui peut être inférieur au nombre demandé (en cas d'erreur) */
166. Prog. struct. C VI- La gestion de fichiers 166
Lecture dans un fichier
• Lecture au format texte :
int fscanf(FILE *pfile,const char *format,…)
/* Lit la chaîne formatée dans le fichier et retourne le nombre de
caractères luts, ou un nombre <0 si erreur */
int fgetc(FILE *pfile)
/* Renvoie le caractère 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 caractères dans le fichier et les place dans l'espace
pointé par s. S'arrête lorsqu'elle a lu n-1 caractères ou lorsqu'elle
a rencontré un caractère '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
indiquée, et les copie les uns à la suite des autres dans l'espace
pointé par destination */
167. Prog. struct. C VI- La gestion de fichiers 167
Positionnement dans un fichier
• Déplacement :
int fseek(FILE *pfile,long deplacement,int orig)
avec orig = SEEK_SET le début du fichier,
SEEK_CUR la position courante,
SEEK_END la fin du fichier
• Re-positionnement au début du fichier :
void rewind(FILE *pfile)
• Connaître la position dans le fichier :
void fgetpos(FILE *flot, fpos_t *ptr)
/*Place dans ptr la position courante dans le fichier indiqué en
vue de son utilisation par fsetpos*/
Fixer la position dans le fichier :
void fsetpos(FILE *flot, const fpos_t *ptr)
A utiliser avec précaution !!
168. Prog. struct. C VI- La gestion de fichiers 168
Renommer ou Supprimer
un fichier
• Renommer
int rename(const char *ancienNom, const char
*nouveauNom);
• Supprimer
int remove(const char *FichieraSuppr);
169. Prog. struct. C VI- La gestion de fichiers 169
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 après la virgule (.)
• type : 1) Flottants e,E,f,g,G
2) Entiers généralisés c,d,i,o,u,x,X
3) Chaînes de caractères s
[{h|L|l}] en option h pour court, l ou L pour long
170. Prog. struct. C VI- La gestion de fichiers 170
Formats de lecture
%[*] [width] [{h | l }]type
• Même signification de width et de type.
• * signifie que la lecture suivante sera faite, mais
non transférée en mémoire.
171. Prog. struct. C VI- La gestion de fichiers 171
Flots textes formatés
• 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,…)
172. Prog. struct. C VI- La gestion de fichiers 172
...
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 %sn", art.nom, art.prenom)) != 2)
break;
...
}
...
}
Exemple 1 :
texte formaté -> fichier binaire
fichier.prj
173. Prog. struct. C VI- La gestion de fichiers 173
#include <stdio.h>
int main()
{
const double pi=4*atan(1);
printf("%lfn",pi);
printf("%1.3lf",pi);
}
Exemple 2 : les formats
formats.prj
175. Prog. Struct. C IX - Prog. Modulaire 175
Généralités
• Un logiciel doit être conçu comme la réunion de
plusieurs modules,
• Chaque module regroupe des fonctions de même
nature (Graphisme, Algorithmes principaux,
interface utilisateur, …),
• Un seul des modules contient la fonction main ().
176. Prog. Struct. C IX - Prog. Modulaire 176
Les avantages …
• En séparant les fonctionnalités du projet en unités
le moins possible interdépendantes, on simplifie la
mise au point du logiciel qui se fait module par
module.
• La compilation est beaucoup plus rapide, car seuls
les modules modifiés sont compilés.
• Certains modules (s’ils sont bien conçus) peuvent
être ré-utilisés dans d’autres projets.
177. Prog. Struct. C IX - Prog. Modulaire 177
La mise en œuvre
En-tête
Fonction main
Définition de
vos fonctions
Programme monofichier ⇒ Programme modulaire
Fichiers .h
Fichier .c Fichiers .c
Sans fonction
main()
Module
178. Prog. Struct. C IX - Prog. Modulaire 178
Conséquences :
Le fichier *.prj s'agrandit
179. Prog. Struct. C IX - Prog. Modulaire 179
Le contenu de l'en-tête
Directives de pré-processeur : #xxxx
Ex : #include <stdio.h> ou #define PI 3.14159
Déclaration des types utilisateurs : struct
Ex : struct POLYTECH
Définition des variables de portée fichier (globales)
Ex : static int panelhandle;
Déclaration des variables définies de manière externe
Ex : extern
Déclaration des prototypes des fonctions
Ex : void ma_fonction(void);
++++ ⇒ Mon_Fichier.h
180. Prog. Struct. C IX - Prog. Modulaire 180
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
181. Prog. Struct. C IX - Prog. Modulaire 181
La directive #include
/* C'est le contenu du
fichier.h qui est
recopié en en-tête
du fichier.c */ #include "fichier.h"
int main()
{
}
/*fichier .c */
182. Prog. Struct. C IX - Prog. Modulaire 182
La directive #define
• Syntaxe :
#define BUFSIZE 512
#define PI 3.14159
• Action : Rechercher/Remplacer
Partout où la chaîne de caractères BUFSIZE
est rencontrée, elle est remplacée par 512
La compilation se fera sur le code transformé!
183. Prog. Struct. C IX - Prog. Modulaire 183
#define pour la taille des tableaux
#define NMAX 10
....
int main()
{
float vect[NMAX];
for(i=0 ; i<NMAX; i++)
{ ....
}
}
Le programme est
développé avec 10 pour
remplacer NMAX.
Après le programmeur
pourra mettre 10000 ...
184. Prog. Struct. C IX - Prog. Modulaire 184
Comment faire une Macro ?
Au sein d'un #define
• Exemple :
#define MAX(a,b) (((a)>(b))?(a):(b))
MAX(expr1,expr2) sera utilisée comme
(((expr1)>(expr2))?(expr1):(expr2))
Les parenthèses servent à fixer les priorités.
185. Prog. Struct. C IX - Prog. Modulaire 185
Comment faire une Macro ?
• Autre Exemple :
#define MAJEUR(age) if (age>=18)
printf("Vous etes majeur");
int main()
{
MAJEUR(22);
}
Lors de l'exécution il s'affichera :
Vous etes majeur
186. Prog. Struct. C IX - Prog. Modulaire 186
Avantages des macros
• Remplacer des fonctions courtes.
Le temps d’exécution du programme puisqu’il n’y a
pas d’appel de fonction.
Mais le code exécutable est plus long.
• Les compilateurs modernes utilisent les macros pour
générer automatiquement du code répétitif à la place du
programmeur.
187. Prog. Struct. C IX - Prog. Modulaire 187
Définition 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
188. Prog. Struct. C IX - Prog. Modulaire 188
Les variables globales
en programmation modulaire
• Une variable globale a la portée et la durée
de vie du programme.
189. Prog. Struct. C IX - Prog. Modulaire 189
Les variables globales
en programmation modulaire
Pour être reconnue par le compilateur dans
d'autres modules du programme, elle doit :
- y être déclarée mais sans réservation de
mémoire,
- et précédée de extern dans un fichier .h à
inclure dans les fichiers .c, où cette variable
est utilisée.
190. Prog. Struct. C IX - Prog. Modulaire 190
Les variables globales
(suite)
• Si, on veut restreindre la portée de cette
variable au seul module où elle a été définie, on
fait précéder sa définition de static.
• Dans d’autres modules, une autre variable de
portée fichier de même identificateur pourra
être définie sans conflit de déclaration.
191. Prog. Struct. C IX - Prog. Modulaire 191
Exemple
modulaire.prj
192. Allocation Dynamique
de Mémoire
1. Généralités
2. Les fonctions malloc() & Cie
Département Génie Civil & Département Mécanique Énergétique
Département Génie Civil & Département Mécanique Énergétique
193. Prog. struct. C X - Alloc. dyn. mem. 193
Quand l'utiliser ?
• Si le nombre d’objets à stocker dans le
tableau n’est connu qu’à l’exécution, il faut
avoir recours à l’allocation dynamique.
• Pour les tableaux à plusieurs indices même si
les dimensions sont connues à priori.
• Pour stoker des données volumineuses.
194. Prog. struct. C X - Alloc. dyn. mem. 194
Déclaration de variables
=
Demande d'allocation mémoire
int maVariable = 12;
1) le programme demande à Windows la permission
d'utiliser un peu de mémoire,
2) Windows répond en indiquant où votre
programme peut stocker maVariable
il lui alloue une adresse
3) lorsque la fonction est terminée, maVariable
est automatiquement supprimée de la mémoire.
Votre programme dit à Windows "Je n'ai plus besoin
de cet espace mémoire"
195. Prog. struct. C X - Alloc. dyn. mem. 195
Connaître la taille des variables grâce à
sizeof()
sizeof(char) 1
sizeof(short int) 2
sizeof(int) 4
sizeof(double) 8
sizeof(int *) 4
196. Prog. struct. C X - Alloc. dyn. mem. 196
Configuration de la mémoire
pendant l’exécution
OS (windows par ex.)
Programme Pile
Variables
statiques
Tas
Le tas (heap) est
la mémoire
inutilisée lors de
l’exécution du
programme.
C'est là que va se faire l'allocation dynamique de
mémoire.
197. Prog. struct. C X - Alloc. dyn. mem. 197
La Mise en œuvre
Il faut :
• Une variable de type pointeur sur la donnée
à stocker
• Utiliser la fonction malloc() ou une similaire
pour affecter une adresse à cette variable.
• Libérer la mémoire lorsque l'on en n'a plus
besoin avec la fonction free().
198. Prog. struct. C X - Alloc. dyn. mem. 198
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));
Taille d'une variable de type ELP
On type l'adresse
199. Prog. struct. C X - Alloc. dyn. mem. 199
La fonction malloc()…
• Erreur mémoire insuffisante :
Quand la demande ne peut pas être satisfaite,
la fonction malloc()retourne le pointeur NULL.
D’où le test d’erreur :
if (pTabElev == NULL)
{
… Gestion Erreur
}
200. Prog. struct. C X - Alloc. dyn. mem. 200
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));
}
201. Prog. struct. C X - Alloc. dyn. mem. 201
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 réservés.
• Si mémoire insuffisante réagit comme malloc()
202. Prog. struct. C X - Alloc. dyn. mem. 202
La fonction realloc()
• Prototype :
void *realloc (void *ptrAlloc,size_t New_Size);
• Si la taille de la mémoire précédemment allouée doit être
réduite.
Le contenu du pointeur et de la mémoire sont préservés.
203. Prog. struct. C X - Alloc. dyn. mem. 203
La fonction free()
• Prototype :
void free (void * pMemAlloue);
• Appel :
free(pTabElev);
• Action :
Libère la zone mémoire allouée par une des fonctions de
la famille malloc().
Doit s’utiliser dès que l’on n’a plus besoin de cette
mémoire.
204. Prog. struct. C X - Alloc. dyn. mem. 204
La fonction free() …
• Si la fonction free() a pour paramètre la valeur
NULL, elle s’exécute sans erreur et sans rien faire.
• si l'adresse passée à free() ne résulte pas d’un
appel à une fonction de la famille malloc(), le
résultat est catastrophique !!!
!
205. Prog. struct. C X - Alloc. dyn. mem. 205
Exemple
allocat.prj
206. Prog. struct. C X - Alloc. dyn. mem. 206
Les listes chaînées
- Ça sert à organiser ses données en mémoire.
- C'est beaucoup plus flexible qu'un tableau !!!
- mise en œuvre avec des structures...
207. Prog. struct. C X - Alloc. dyn. mem. 207
Listes chaînées vs Tableaux
1 Tableau
Une fois créé, on ne
peut plus le modifier !
208. Prog. struct. C X - Alloc. dyn. mem. 208
Listes chaînées vs Tableaux
1 Liste Une fois créée, on peut la modifier !
209. Prog. struct. C X - Alloc. dyn. mem. 209
Construction d'une liste
chaînée
Exemple : une liste de nombres ou d'étudiants …
Comment créer un ?
typedef struct Element Element;
struct Element
{
int nombre;
Element *suivant_sur_la_liste;
};
210. Prog. struct. C X - Alloc. dyn. mem. 210
Pour contrôler l'ensemble de la liste, il faut :
typedef struct Liste Liste;
struct Liste
{
Element *premier_sur_la_liste;
};
Puis il faut écrire les fonctions gérant la liste :
- pour l'initialiser,
- pour ajouter un élément,
- pour supprimer un élément,
- pour afficher le contenu de la liste,
- pour supprimer la liste entière..
211. Prog. struct. C X - Alloc. dyn. mem. 211
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;
}
212. Progr. struct. - C Bibliographie 212
Pour en savoir plus
A la bibliothèque en salle 112 :
• H. Garreta, C: Langage, bibliothèque, applications,
InterEditions (1992)
• B. Kernighan et D. Ritchie, Le Langage C, Masson
(Dernière Edition) - Pour se perfectionner.
• B. Gottfried, Programmation en C, Série Schaum,
Pour les exercices.
• H. Schildt, Référence Complète C++, First Interactive
(2002).
213. Progr. struct. - C Sources 213
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++
• À télécharger à partir de
http://www.commentcamarche.net