Cours de c

Programmation Structurée
Langage C
Laurence.Bergougnoux@univ-amu.fr
http://iusti.polytech.univ-mrs.fr/~bergougnoux/
Département Génie Civil & Département Mécanique Énergétique

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

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

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

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)

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

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

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++
...

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

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)

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

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.

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

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.

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

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.

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 …

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.

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

Premier Programme
en langage C
sous LabWindows/CVI
source_1.c

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()

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

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.

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

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

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

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
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 0 1 0
• des nombres réels
197,75 = 128 + 64 + 4 + 1 , 0.5 + 0.25
= 27
+ 26
+ 22
+20
, 2-1
+ 2-2
= 11000101,11
= 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 0 0 0 0 1 1 0 1 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
signe
mantisse
exposant

Les pointeurs
0x0000 à 0xFFFF
0x00000000 à 0xFFFFFFFF
2 (sur 16 bits)
4 (sur 32 bits)
adresse
*pointeur
Plage de valeurs
Taille (octet)
Signification
Type

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

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

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

#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;

• 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 :

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

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

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));

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
 

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

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

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

Les priorités
() []
-- ++ ! ~ -
* / %
+ -
<< >>
< <= >= >
== !=
&
^
|
&& ||
?:
= += -= etc.…
+++
---

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  { }

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 ...

L'instruction if
• syntaxe :
if(condition)
{
instructions;
}
condition
instructions
VRAI
FAUX

L'instruction if(condition)…else
• syntaxe :
if(condition)
{
instructions;
}
else
{
instructions;
}
condition
instructions
VRAI
FAUX
instructions

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");
}
{ }
{ }

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

L'opérateur conditionnel
(condition) ? instruction_vrai : instruct_faux
• exemple :
x = 3;
y = 2;
max_xy = ((x>=y) ? x : y);
=
1
max_xy = x;

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

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
?

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;
}

Les instructions de boucle :
pour répéter les
mêmes instructions
plusieurs fois

L'instruction while
• tant que (condition vraie)
• syntaxe :
while(condition)
{
instructions;
}
condition
VRAI
FAUX
instructions

L'instruction do…while
• faire … tant que (condition vraie)
• syntaxe :
do
{
instructions;
}while(condition);
condition
VRAI FAUX
instructions

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

Attention aux boucles sans fin
•exemple :
for( ; ; )
{
printf("sans finn");
}
;
1
Affichage
"sans fin"
V
F
;

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 ?

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
continue
• exemple :
x=1;
while(x<=10)
{
if (x==7)
{ printf("division par 0");
x++;
continue;
}
a=1/(x-7);
printf("%f",a);
x++;
}

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 ?

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

return
• syntaxe :
return(expression);
• exemple :
int main()
{
…
return(0);
}

Exemples
– Résolution numérique d'une équation du second
degré
– Programme mystère
– Affectation et récurrence

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

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

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é

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

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*/

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*/

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*/

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

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);
}

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.

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.

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

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

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).

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

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

Mémoire, adresse et pointeur
http://www.siteduzero.com/

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





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
 


& 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

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é.

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

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 …

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.

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

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

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]);

Exemple : Saisir et afficher
les éléments d'un tableau
Mon premier tableau

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

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);

Pour comprendre
'o'
'B' 'n' 'j' 'o' 'u' 'r' Ø
cBonjour pfin ← cBonjour+3
printf("%sn", cBonjour); Bonjour↵
pfin = cBonjour + 3;
printf("%sn", pfin); jour↵

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

Chaîne de Caractères
Exemple
!OG

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]);

Tableau à deux indices
...
NCol NCol NCol
NLign x NCol
Ligne0 Ligne1

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

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

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 !!

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.

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.

Instruction i ;
Appel MaFonction() ;
Instruction i+2 ;
Ligne n°1 de MaFonction()
La suite de MaFonction()
Instruction return();
MaFonction
Adresse

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 ;

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.

Instruction i;
MaFonction(10,x+y,z);
MaFonction {
Instructions
De MaFonction
…
return;
}
Instruction_suiv;
Passage de
paramètres
10
x+y
z

Fonction : Mise en œuvre
#include <stdio.h>
/* 2) Le prototypage */
int main()
{
…
/* 3) L'appel */
…
}
/* 1) La définition */

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

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()
{
…
}

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é

Ma première fonction
fonctionsexemple1.prj

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);
}

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;
}

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

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

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;
}

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é !

//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

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);

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

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 !

Exemple
val_et_adr.prj
Ma deuxième fonction

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.

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 ?

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.
!

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

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

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!!!

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);

• 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

4) Les Pointeurs sur fonction
• Déclaration
• Affectation
• Utilisation

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.

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;

pointfonct.prj
Pointeurs sur fonction

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

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 ≠

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.

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

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

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;

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()
{
…
}

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

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

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;
⇔

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;
}

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

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

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

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.

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};

Exemple
enum tdepart{GC,GII,ME,MT};
typedef enum tdepart DEPART;
…
POLYTECH *pElev;
… /*Mettre une adresse valide dans pElev*/
pElev->Depart = MT;
…

La gestion de fichiers
1. Les Flots
2. Ouverture / Fermeture d'un fichier
3. Lecture / Écriture dans un fichier
4. Formats

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

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.

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

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.

<stdio.h>
standard input output
C'est là qu'est définie la structure FILE !

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().

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

• 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

#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

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.

#include <stdio.h>
int main()
{
fprintf(stdout,"1ere alternative à printf()n");
fputs("n En voila une autre",stdout);
}
Exemple
ecran.prj

É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) */

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 */

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 !!

Renommer ou Supprimer
un fichier
• Renommer
int rename(const char *ancienNom, const char
*nouveauNom);
• Supprimer
int remove(const char *FichieraSuppr);

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

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.

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,…)

...
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

#include <stdio.h>
int main()
{
const double pi=4*atan(1);
printf("%lfn",pi);
printf("%1.3lf",pi);
}
Exemple 2 : les formats
formats.prj

Programmation modulaire
(multi-fichiers)
1. Généralités
2. Mise en œuvre
3. Macros
4. Variables de portée fichier

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 ().

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.

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

Conséquences :
Le fichier *.prj s'agrandit

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

 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

 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 */

 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é!

#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 ...

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.

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

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.

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

 Les variables globales
en programmation modulaire
• Une variable globale a la portée et la durée
de vie du programme.

 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.

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.

Exemple
modulaire.prj

Allocation Dynamique
de Mémoire
1. Généralités
2. Les fonctions malloc() & Cie

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.

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"

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

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.

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().

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

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
}

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));
}

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()

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.

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.

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 !!!

!

Exemple
allocat.prj

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...

Listes chaînées vs Tableaux
1 Tableau
Une fois créé, on ne
peut plus le modifier !

Listes chaînées vs Tableaux
1 Liste Une fois créée, on peut la modifier !

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;
};

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..

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;
}

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).

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

Cours de c

Contenu connexe

Tendances

En vedette

Similaire à Cours de c

Cours de c