SlideShare une entreprise Scribd logo
1  sur  213
Télécharger pour lire hors ligne
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
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
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
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)
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
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
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++
...
Progr. struct. - C Introduction 9
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
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)
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
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.
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
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.
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
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.
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 …
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.
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
Progr. struct. - C 1er programme 21
Premier Programme
en langage C
sous LabWindows/CVI
source_1.c
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()
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
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.
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
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
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
Prog. Struct. - C 1. Les types de données 28
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
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
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
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
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
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;
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 :
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
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
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));
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
 
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
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
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
Prog. Struct. - C 3. Les opérateurs 42
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  { }
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 ...
Prog. Struct. - C 4. Les structures conditionnelles 45
L'instruction if
• syntaxe :
if(condition)
{
instructions;
}
condition
instructions
VRAI
FAUX
Prog. Struct. - C 4. Les structures conditionnelles 46
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");
}
{ }
{ }
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
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;
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
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
?
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;
}
Prog. Struct. - C 4. Les instructions conditionnelles 53
Les instructions de boucle :
pour répéter les
mêmes instructions
plusieurs fois
Prog. Struct. - C 4. Les instructions conditionnelles 54
L'instruction while
• tant que (condition vraie)
• syntaxe :
while(condition)
{
instructions;
}
condition
VRAI
FAUX
instructions
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
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
Prog. Struct. - C 4. Les instructions conditionnelles 57
Attention aux boucles sans fin
•exemple :
for( ; ; )
{
printf("sans finn");
}
;
1
Affichage
"sans fin"
V
F
;
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 ?
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++;
}
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 ?
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
Prog. Struct. - C 4. Les instructions conditionnelles 62
Les instructions de sortie :
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
Département Génie Civil & Département Mécanique Énergétique
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
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
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é
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
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*/
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*/
 
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*/
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
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);
}
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.
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.
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
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
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).
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
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
Prog. struct. : C III-Les pointeurs ... 80
Mémoire, adresse et pointeur
http://www.siteduzero.com/
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




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
 

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
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é.
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
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 …
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.
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
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
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]);
Prog. struct. : C III- ... Les tableaux 91
Exemple : Saisir et afficher
les éléments d'un tableau
Mon premier tableau
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
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);
Prog. struct. : C III- ... Les tableaux 94
Pour comprendre
'o'
'B' 'n' 'j' 'o' 'u' 'r' Ø
cBonjour pfin ← cBonjour+3
printf("%sn", cBonjour); Bonjour↵
pfin = cBonjour + 3;
printf("%sn", pfin); jour↵
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
Prog. struct. : C III- ... Les tableaux 96
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]);
Prog. Struct. - C III - ... Les tableaux 98
Tableau à deux indices
...
NCol NCol NCol
NLign x NCol
Ligne0 Ligne1
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
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
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 !!
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.
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.
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
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 ;
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.
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
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 */
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
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()
{
…
}
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é
Prog. Struct. - C IV - Les Fonctions 112
Ma première fonction
fonctionsexemple1.prj
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);
}
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;
}
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
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
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;
}
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é !
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
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);
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
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 !
Prog. Struct. - C IV - Les Fonctions 123
Exemple
val_et_adr.prj
Ma deuxième fonction
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.
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 ?
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.
!
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
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
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!!!
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);
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
Prog. Struct. - C IV - Les Fonctions 132
4) Les Pointeurs sur fonction
• Déclaration
• Affectation
• Utilisation
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.
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;
Prog. Struct. - C IV - Les Fonctions 135
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
Département Génie Civil & Département Mécanique Énergétique
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 ≠
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.
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
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
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;
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()
{
…
}
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
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
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;
⇔
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;
}
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
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
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
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};
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;
…
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
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
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.
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
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.
Prog. struct. C VI- La gestion de fichiers 158
<stdio.h>
standard input output
C'est là qu'est définie la structure FILE !
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().
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
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
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
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.
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
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) */
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 */
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 !!
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);
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
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.
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,…)
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
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
Programmation modulaire
(multi-fichiers)
1. Généralités
2. Mise en œuvre
3. Macros
4. Variables de portée fichier
Département Génie Civil & Département Mécanique Énergétique
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 ().
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.
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
Prog. Struct. C IX - Prog. Modulaire 178
Conséquences :
Le fichier *.prj s'agrandit
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
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
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 */
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é!
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 ...
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.
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
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.
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
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.
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.
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.
Prog. Struct. C IX - Prog. Modulaire 191
Exemple
modulaire.prj
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
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.
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"
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
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.
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().
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
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
}
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));
}
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()
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.
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.
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 !!!

!
Prog. struct. C X - Alloc. dyn. mem. 205
Exemple
allocat.prj
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...
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 !
Prog. struct. C X - Alloc. dyn. mem. 208
Listes chaînées vs Tableaux
1 Liste Une fois créée, on peut la modifier !
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;
};
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..
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;
}
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

Contenu connexe

Tendances

Merise+ +exercices+mcd+-+corrigés
Merise+ +exercices+mcd+-+corrigésMerise+ +exercices+mcd+-+corrigés
Merise+ +exercices+mcd+-+corrigés
Majid CHADAD
 
Correction examen-java-avancé-1
Correction examen-java-avancé-1Correction examen-java-avancé-1
Correction examen-java-avancé-1
vangogue
 

Tendances (20)

PL/SQL:les curseurs
PL/SQL:les curseursPL/SQL:les curseurs
PL/SQL:les curseurs
 
HTML, CSS et Javascript
HTML, CSS et JavascriptHTML, CSS et Javascript
HTML, CSS et Javascript
 
Corrige tp java
Corrige tp javaCorrige tp java
Corrige tp java
 
La programmation modulaire en Python
La programmation modulaire en PythonLa programmation modulaire en Python
La programmation modulaire en Python
 
Introduction à pl/sql
Introduction à pl/sqlIntroduction à pl/sql
Introduction à pl/sql
 
Merise+ +exercices+mcd+-+corrigés
Merise+ +exercices+mcd+-+corrigésMerise+ +exercices+mcd+-+corrigés
Merise+ +exercices+mcd+-+corrigés
 
Algorithmique
AlgorithmiqueAlgorithmique
Algorithmique
 
exercices base de données - sql
exercices  base de données - sql exercices  base de données - sql
exercices base de données - sql
 
patron de conception
patron de conception patron de conception
patron de conception
 
Travaux dirigés 1: algorithme & structures de données (corrigés)
Travaux dirigés 1: algorithme & structures de données (corrigés)Travaux dirigés 1: algorithme & structures de données (corrigés)
Travaux dirigés 1: algorithme & structures de données (corrigés)
 
Uml 2 pratique de la modélisation
Uml 2  pratique de la modélisationUml 2  pratique de la modélisation
Uml 2 pratique de la modélisation
 
Chapitre 5 arbres binaires
Chapitre 5 arbres binairesChapitre 5 arbres binaires
Chapitre 5 arbres binaires
 
Base de donnees Avancees et Intro à NoSQL.ppt
Base de donnees Avancees et Intro à  NoSQL.pptBase de donnees Avancees et Intro à  NoSQL.ppt
Base de donnees Avancees et Intro à NoSQL.ppt
 
Introduction au langage SQL
Introduction au langage SQLIntroduction au langage SQL
Introduction au langage SQL
 
Correction examen-java-avancé-1
Correction examen-java-avancé-1Correction examen-java-avancé-1
Correction examen-java-avancé-1
 
Le langage C
Le langage CLe langage C
Le langage C
 
Cours de programmation en c
Cours de programmation en cCours de programmation en c
Cours de programmation en c
 
Introduction a la compilation Analyse lexicale - C2
Introduction a la compilation  Analyse lexicale - C2Introduction a la compilation  Analyse lexicale - C2
Introduction a la compilation Analyse lexicale - C2
 
Administration des base de donnees sous oracle 10g
Administration des base de donnees sous oracle 10g Administration des base de donnees sous oracle 10g
Administration des base de donnees sous oracle 10g
 
Chp1- Introduction aux Technologies Web et SOA
Chp1- Introduction aux Technologies Web et SOAChp1- Introduction aux Technologies Web et SOA
Chp1- Introduction aux Technologies Web et SOA
 

En vedette

Le livre du_c_pour_les_vrais_d%c3%a9butants_en_programmation
Le livre du_c_pour_les_vrais_d%c3%a9butants_en_programmationLe livre du_c_pour_les_vrais_d%c3%a9butants_en_programmation
Le livre du_c_pour_les_vrais_d%c3%a9butants_en_programmation
Chingongou ­
 
Programmation des pic_en_c_part2
Programmation des pic_en_c_part2Programmation des pic_en_c_part2
Programmation des pic_en_c_part2
oussamada
 
Programmation des pic_en_c_part1
Programmation des pic_en_c_part1Programmation des pic_en_c_part1
Programmation des pic_en_c_part1
oussamada
 
Microcontroleur Pic16 F84
Microcontroleur Pic16 F84Microcontroleur Pic16 F84
Microcontroleur Pic16 F84
guest1e7b02
 

En vedette (20)

STM32F4+Android Application
STM32F4+Android ApplicationSTM32F4+Android Application
STM32F4+Android Application
 
Cours c++
Cours c++Cours c++
Cours c++
 
Algorithme
AlgorithmeAlgorithme
Algorithme
 
Le livre du_c_pour_les_vrais_d%c3%a9butants_en_programmation
Le livre du_c_pour_les_vrais_d%c3%a9butants_en_programmationLe livre du_c_pour_les_vrais_d%c3%a9butants_en_programmation
Le livre du_c_pour_les_vrais_d%c3%a9butants_en_programmation
 
Compteur ARDUINO
Compteur ARDUINOCompteur ARDUINO
Compteur ARDUINO
 
Pic16f84
Pic16f84Pic16f84
Pic16f84
 
Programmation des pic_en_c_part2
Programmation des pic_en_c_part2Programmation des pic_en_c_part2
Programmation des pic_en_c_part2
 
Micocontroleur16 fxxx (1)
Micocontroleur16 fxxx (1)Micocontroleur16 fxxx (1)
Micocontroleur16 fxxx (1)
 
Généralités sur les périphériques du STM32
Généralités sur les périphériques du STM32Généralités sur les périphériques du STM32
Généralités sur les périphériques du STM32
 
Programmation des pic_en_c_part1
Programmation des pic_en_c_part1Programmation des pic_en_c_part1
Programmation des pic_en_c_part1
 
Microcontroleur Pic16 F84
Microcontroleur Pic16 F84Microcontroleur Pic16 F84
Microcontroleur Pic16 F84
 
Cours pics16 f877
Cours pics16 f877Cours pics16 f877
Cours pics16 f877
 
ARDUINO + LABVIEW : CONTRÔLE DE LA TEMPÉRATURE
ARDUINO + LABVIEW : CONTRÔLE DE LA TEMPÉRATUREARDUINO + LABVIEW : CONTRÔLE DE LA TEMPÉRATURE
ARDUINO + LABVIEW : CONTRÔLE DE LA TEMPÉRATURE
 
Ch02
Ch02Ch02
Ch02
 
Microcontroleur
MicrocontroleurMicrocontroleur
Microcontroleur
 
Techniques de programmation avancée LabVIEW : gestion des données de la local...
Techniques de programmation avancée LabVIEW : gestion des données de la local...Techniques de programmation avancée LabVIEW : gestion des données de la local...
Techniques de programmation avancée LabVIEW : gestion des données de la local...
 
Travaux dirigés 1: algorithme & structures de données
Travaux dirigés 1: algorithme & structures de donnéesTravaux dirigés 1: algorithme & structures de données
Travaux dirigés 1: algorithme & structures de données
 
Algorithme & structures de données Chap III
Algorithme & structures de données Chap IIIAlgorithme & structures de données Chap III
Algorithme & structures de données Chap III
 
Présentation d'Arduino
Présentation d'ArduinoPrésentation d'Arduino
Présentation d'Arduino
 
Sujet 6 - Carte Son
Sujet 6 - Carte SonSujet 6 - Carte Son
Sujet 6 - Carte Son
 

Similaire à Cours de c

COURS C++ [Enregistrement automatique]Complet (1).pptx
COURS C++ [Enregistrement automatique]Complet (1).pptxCOURS C++ [Enregistrement automatique]Complet (1).pptx
COURS C++ [Enregistrement automatique]Complet (1).pptx
LuneSabsPericolo1
 
Cours_C_for_Etudiant.pdf
Cours_C_for_Etudiant.pdfCours_C_for_Etudiant.pdf
Cours_C_for_Etudiant.pdf
Hailisara
 

Similaire à Cours de c (20)

Chap1V2019: Cours en C++
Chap1V2019: Cours en C++Chap1V2019: Cours en C++
Chap1V2019: Cours en C++
 
Chap1: Cours en C++
Chap1: Cours en C++Chap1: Cours en C++
Chap1: Cours en C++
 
COURS C++ [Enregistrement automatique]Complet (1).pptx
COURS C++ [Enregistrement automatique]Complet (1).pptxCOURS C++ [Enregistrement automatique]Complet (1).pptx
COURS C++ [Enregistrement automatique]Complet (1).pptx
 
ESGAE_C#_2021-2024 Cours Avancé (('.pptx
ESGAE_C#_2021-2024 Cours Avancé (('.pptxESGAE_C#_2021-2024 Cours Avancé (('.pptx
ESGAE_C#_2021-2024 Cours Avancé (('.pptx
 
C2 - Langage C - ISIMA 1 - Deuxieme partie
C2 - Langage C - ISIMA 1 - Deuxieme partieC2 - Langage C - ISIMA 1 - Deuxieme partie
C2 - Langage C - ISIMA 1 - Deuxieme partie
 
Seance 1 - Programmation en langage C
Seance 1 - Programmation en langage CSeance 1 - Programmation en langage C
Seance 1 - Programmation en langage C
 
Développer des codes de simulation numérique avec une équipe "non geek" à l'ULg
Développer des codes de simulation numérique avec une équipe "non geek" à l'ULgDévelopper des codes de simulation numérique avec une équipe "non geek" à l'ULg
Développer des codes de simulation numérique avec une équipe "non geek" à l'ULg
 
M2 INAE introduction python.pdf
M2 INAE introduction python.pdfM2 INAE introduction python.pdf
M2 INAE introduction python.pdf
 
Cours_C_for_Etudiant.pdf
Cours_C_for_Etudiant.pdfCours_C_for_Etudiant.pdf
Cours_C_for_Etudiant.pdf
 
Chap 1 Initiation.pptx
Chap 1 Initiation.pptxChap 1 Initiation.pptx
Chap 1 Initiation.pptx
 
Technologies du Web - Architectures matérielles et logicielles
Technologies du Web - Architectures matérielles et logiciellesTechnologies du Web - Architectures matérielles et logicielles
Technologies du Web - Architectures matérielles et logicielles
 
Développer en natif avec C++11
Développer en natif avec C++11Développer en natif avec C++11
Développer en natif avec C++11
 
Chapitre 3 - Généralités sur le langage C.pdf
Chapitre 3 - Généralités sur le langage C.pdfChapitre 3 - Généralités sur le langage C.pdf
Chapitre 3 - Généralités sur le langage C.pdf
 
Formation python
Formation pythonFormation python
Formation python
 
Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
Bonnes pratiques pour apprivoiser le C++11 avec Visual C++Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
 
C++ 11 - Tech Days 2014 in Paris
C++ 11 - Tech Days 2014 in ParisC++ 11 - Tech Days 2014 in Paris
C++ 11 - Tech Days 2014 in Paris
 
Chap1_Entrees_Sorties.pptx
Chap1_Entrees_Sorties.pptxChap1_Entrees_Sorties.pptx
Chap1_Entrees_Sorties.pptx
 
Support Formation Samsung - Python - Session 1 - 2022.pptx
Support Formation Samsung - Python - Session 1 - 2022.pptxSupport Formation Samsung - Python - Session 1 - 2022.pptx
Support Formation Samsung - Python - Session 1 - 2022.pptx
 
introduction au CPP
introduction au CPPintroduction au CPP
introduction au CPP
 
Langage C
Langage CLangage C
Langage C
 

Cours de c

  • 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++ ...
  • 9. Progr. struct. - C Introduction 9
  • 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
  • 28. Prog. Struct. - C 1. Les types de données 28 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
  • 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
  • 42. Prog. Struct. - C 3. Les opérateurs 42 Les priorités () [] -- ++ ! ~ - * / % + - << >> < <= >= > == != & ^ | && || ?: = += -= etc.… +++ ---
  • 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
  • 46. Prog. Struct. - C 4. Les structures conditionnelles 46 L'instruction if(condition)…else • syntaxe : if(condition) { instructions; } else { instructions; } condition instructions VRAI FAUX instructions
  • 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);
  • 94. Prog. struct. : C III- ... Les tableaux 94 Pour comprendre 'o' 'B' 'n' 'j' 'o' 'u' 'r' Ø cBonjour pfin ← cBonjour+3 printf("%sn", cBonjour); Bonjour↵ pfin = cBonjour + 3; printf("%sn", pfin); jour↵
  • 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
  • 174. Programmation modulaire (multi-fichiers) 1. Généralités 2. Mise en œuvre 3. Macros 4. Variables de portée fichier Département Génie Civil & Département Mécanique Énergétique
  • 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