Upload
others
View
2
Download
0
Embed Size (px)
Citation preview
L2 - UE Programmation 3Langage C2009 2010
Equipe pédagogique:Florence Cloppet
Neilze DortaDavid Janiszek
[email protected]@mi.parisdescartes.fr
UE programmation 3 – F. Cloppet 2
Sommaire
1. Informations administratives2. Introduction3. Programmer en Langage C4. Notions de Langage C
1. Variables , Constantes2. Opérateurs3. Fonctions4. Pointeurs5. Tableaux6. Tableaux de caractères – chaîne de caractères7. Synthèse Tableaux - Pointeurs / Tableau de Pointeurs8. Structures – Unions – Énumérations9. Fichiers10. Pré-processeur11. Compilation séparée12. Intégration d’un programme C dans l’environnement hôte
UE programmation 3 – F. Cloppet 3
Informations Administratives (1)
� Emploi du Temps
� Cours lundi 13h00-14h30 amphi Giroud
� L2 : 1TD et 1TP / semaine
� groupe 5
� lundi 8h30-10h et 10h15-12h15 : D. Janizsek
� groupe 8
� mardi 10h15-11h45 et 12h45-14h45 : F. Cloppet
� groupe 4
� jeudi 12h30-14h00 et 14h15-16h15 : N. Dorta
� groupe 6
� jeudi 14h30-16h00 et 16h30-18h30 : D. Janizsek
UE programmation 3 – F. Cloppet 4
Informations Administratives (2)
� Contrôle des Connaissances
� 1 Contrôle Continu sur machine à la mi-novembre (CC)
� 1 examen final (sur papier)
� Note finale = max ((CC+Examen) /2, Examen)
UE programmation 3 – F. Cloppet 5
Bibliographie
� La Bible ….� Le langage C Norme ANSI , Brian W. Kernighan et Dennis M. Ritchie, Dunod 2ème Edition (2004)
� Un peu plus pédagogique� Programmer en langage, Claude Delannoy, Eyrolles
(2002)
UE programmation 3 – F. Cloppet 6
Remarque
Poly disponible sur http://www.math-info.univ-paris5.fr/~cloppet/prog3/PolyProg3_2009.pdf
Attention ceci n’est qu’un résumé à trous …des transparents de cours
�Ce poly n’est là que pour vous aider à la prise de notes et ne vous dispense en aucun cas d’assister au cours !!!!
UE programmation 3 – F. Cloppet 7
Introduction / Notions de base (1)
� Un ordinateur permet :� la saisie d’informations ,� le traitement des informations saisies ,� le stockage des informations et des résultats des traitements ,� la visualisation des résultats.
� Un système informatique
CPU
Moniteur
Mémoire centrale
RAM
ROM
ImprimanteClavier
Disque Dur
Disquette
CDROM
UE programmation 3 – F. Cloppet 8
Introduction / Notions de base (2)
� l’utilisateur et les programmes� système d’exploitation� les programmes applicatifs � programmes développés
� Relations programmes - Machines � système binaire =>langage machine
� langage d’assemblage ou assembleur
� langages de haut niveau
UE programmation 3 – F. Cloppet 9
Introduction / Activité de programmation (1)
� Étudier le problème à résoudre� solution programmable ?
� Développer un programme optimal� programme fait ce qu’il est censé faire� programme prend en compte les situations anormales� programme facile à modifier et à étendre
� Limiter les coûts de production
� Appel aux techniques du génie logiciel � le développement d’un logiciel doit être divisé en plusieurs parties pour
être contrôlable
� modèles de développement de logiciels
UE programmation 3 – F. Cloppet 10
Introduction / Activité de programmation (2)
Enoncé du
problèmeProblème Spécification
du système Saisie des
exigences exigences
fonctionnelles
Modèles abstraits
du système
conception
initiale
conception
finale
Modèle final
(code source)Solution
livraison
Aspects de conception liés aux problèmes
impliquant le monde réel
Aspects de conception liés
à la conception elle-même
améliorations
successives
Vue générale des activités de développement d’un système
UE programmation 3 – F. Cloppet 11
Introduction / Langage C
� Conçu par B.W. Kernighan et D.M. Ritchie (années 1970)�pour développer le système d’exploitation Unix sur les stations de
travail
� Langage structuré de haut niveau (fonctions, structures de contrôle etc.)
� Langage de bas niveau (opérateurs permettant de travailler au niveau du codage machine)
� Il s’étend des stations de travail aux micro-ordinateurs
� Norme C ANSI (American Standards National Institute)�donner une définition non ambiguë et indépendante de la machine
� C++ est une extension de C
UE programmation 3 – F. Cloppet 12
Programmer en Langage C (1)
� Réflexion (PHASE PRIMORDIALE)
� Saisie des instructions du code dans un fichier texte� fichier source qui doit avoir comme extension .c
� Une application peut être conçue comme une collection de modules, chaque module pouvant être :� une collection de sous-programmes,
� une collection de données partagées.
� De tels modules peuvent constituer des unités de programmes en C chacune mémorisée dans un fichier.
� Une unité de programme constitue une unité de compilation ou projet.
UE programmation 3 – F. Cloppet 13
Programmer en Langage C (2)
fic1.c fic1.h fic2.c fic2.h
cc -c fic1.c cc -c fic2.c
fic1.o fic2.o
cc fic1.o fic2.o -o toto
toto
Exemple des phases de compilation et d'édition
de liens avec le compilateur cc sous UNIX.
� Compilation (3 étapes)� phase de pré-processing des
fichiers *.c
� compilation des fichiers *.c
� édition des liens
UE programmation 3 – F. Cloppet 14
Programmer en Langage C / Illustration par l’exemple
#include <stdio.h> on demande d'inclure la librairie stdio.h.
void main() la fonction main sans argument
{ début du bloc de la fonction main
/* Ecriture de Bonjour */ un commentaire
printf("Bonjour !\n"); une instruction composée de la fonction printf
} fin du bloc de la fonction main
Après compilation de bonjour.c, le lancement du programme affiche àl'écran :
Bonjour !
UE programmation 3 – F. Cloppet 15
Programmer en Langage C / Programme ? (1)
� programme = traduction en instructions
� Exemple : problème : Affichage des carrés des nombres de 0 à 9
Algorithme :
Calculer puis afficher le carré de 0Calculer puis afficher le carré de 1
..........Calculer puis afficher le carré de 8Calculer puis afficher le carré de 9
UE programmation 3 – F. Cloppet 16
Programmer en Langage C / Programme ? (2)
Programme :
#include <stdio.h>
void main()
{
printf("Le carré de 0 est %d\n", 0*0);
printf("Le carré de 1 est %d\n", 1*1);
…… etc………
printf("Le carré de 8 est %d\n", 8*8);
printf("Le carré de 9 est %d\n", 9*9);
}
Le carré de 0 est 0 Le carré de 1 est 1 Le carré de 2 est 4 Le carré de 3 est 9 Le carré de 4 est 16 Le carré de 5 est 25 Le carré de 6 est 36 Le carré de 7 est 49 Le carré de 8 est 64 Le carré de 9 est 81
UE programmation 3 – F. Cloppet 17
Programmer en Langage C / Programme ? (3)
#include <stdio.h> On demande d'inclure la librairie stdio.h.#define NBFOIS 10 définition de la constante symbolique NBFOIS = 10
int carre (int a) définition de la fonction carre{ début du bloc de la fonction carre
return (a * a); on retourne la valeur entière a*a} fin du bloc de la fonction carre
void main() définition de la fonction main{ début du bloc de la fonction main
int i, j; déclaration des variables entières i et j
for(i = 0; i < NBFOIS; i++){ boucle for de 0 à NBFOIS-1j = carre(i); appel de la fonct. carre et affect. du résultat à jprintf("Le carré de %d est %d\n",i,j);
} fin du bloc for
} fin du bloc de la fonction main
UE programmation 3 – F. Cloppet 18
Programmer en Langage C /Structure d’un programme C
#include <fichier d'entête>
#define constante valeur
typedef struct duo {
int a, b;
}tduo;
extern int VarGlobaleExt;
typefct1 fonction1(int, char);
typefct2 fonction2(int, int);
int VarGlobaleInt;
typefct1 fonction1(int a, char b)
{
return(variable1);
}
typefct2 fonction2(int a, b)
{
return(variable2);
}
void main()
{
int a, b;
a = fonction1(2,'a');
b = fonction2(2,3);
}
Directives de compilation
du préprocesseur
Définitions des types
Définitions des fonctions
et variables externes
Définitions des variables globales
au fichier
Définitions des fonctions
Définition de la fonction main et
appel d'autres fonctions.
monfichier.c
Définitions des fonctions
Paramétrage des fonctions internes
UE programmation 3 – F. Cloppet 19
Notions Langage C
� Identificateurs� lettres ou lettres et chiffres ( taille < 31)� pas de caractères d’espacement� C fait la différence entre majuscule et Minuscule (toto est différent de
Toto)� donner des noms qui indiquent le rôle de la variable ou de la fonction� Mots clés et opérateurs réservés
� Variables� stocker des valeurs numériques qui peuvent changer� type� définition / déclaration� Initialisation
� Constantes (#define / const)
UE programmation 3 – F. Cloppet 20
Notions Langage C / Variables (1)� Type d’une variable = défini suivant le type de valeurs qu’elle peut
prendre
� Types diffèrent par la place mémoire occupée
� char => caractère (1 octet) = 2 8 = 256 valeurs� En C un caractère est un entier car il s'identifie à son code ASCII (le plus
souvent).� On peut donc appliquer toutes les opérations entières sur les caractères
(addition, soustraction, etc.).char c;c = 'a' => c = 97
c = c + 1c = 'b' => c = 98
� int => entiers (2 octets) = 2 16 = 65 536 valeurs
UE programmation 3 – F. Cloppet 21
Notions Langage C / Variables (2)
� float => réels (4 octets)
� double => grands réels (8 octets)
� En C, il n’existe pas de type booléen � Par convention : 0 � faux
tout entier différent de 0 � vrai
� Combinaison avec les mots short, long, unsigned, signed� long int => 4 ou 8 octets� signed char => [-128, 127]� unsigned char => [0, 255]
UE programmation 3 – F. Cloppet 22
Notions Langage C / Variables (3)
� Syntaxe de déclaration d’une variable
NomDuType1 NomDeVariable1, NomDeVariable2 ;NomDuType2 NomDeVariable ;
� Exemple:int A; => A est une variable de type entier
=> A représente le contenu d’un emplacement mémoire=> l ’emplacement mémoire ( = adresse mémoire) qui
comporte la valeur de la variable A est obtenu par &A
&A
……..
OXf1 OXf2 OXf3
UE programmation 3 – F. Cloppet 23
Notions Langage C / Variables (4)
� Où et quand déclarer les variables ?� En dehors du corps des fonctions� Dans le corps d’une fonction� En début d’un bloc� Dans tous les cas, AVANT de les utiliser
� Visibilité des Variables� variables déclarées en dehors de toute fonction = variables globales
=> visibles dans toutes les fonctions du fichier où elles sont déclarées
� variables déclarées dans un bloc = variables locales ou variables automatiques=> visibles uniquement dans le bloc où elles sont déclarées et
dans les sous-blocs de celui-ci
� Une variable locale qui a le même nom qu’une variable globale masque la variable globale dans la zone de visibilité de la variable locale
UE programmation 3 – F. Cloppet 24
Notions Langage C / Variables (5)
� Durée de vie des variables� locales : variable est allouée à chaque entrée dans le bloc et elle est
détruite à la sortie du bloc (=> perte de sa valeur)
� globales: variable est allouée en début de programme et est détruite à la fin du programme
� Initialisation� initialiser une variable = lui affecter une valeur initiale
=> peut se faire en même temps que sa déclaration
=> Ex: int A=10 ;
� variable globale: automatiquement initialisée à 0 lors de sa définition
� variable locale: si pas d’initialisation, sa valeur n’est pas définie
&A
……..
OXf1 OXf2 OXf3
10
UE programmation 3 – F. Cloppet 25
Notions Langage C / Variables (6)
� Classes particulières de variables
� extern : utilisé pour des variables globales déclarées dans d’autres fichiers
ex: extern int A ;
� register : variables de type registre sont stockées dans un registre
� static : � variable globale : variable sera invisible dans les autres fichiers
� variable locale à une fonction: la variable n’est pas détruite à la fin de l ’appel de la fonction
UE programmation 3 – F. Cloppet 26
Notions Langage C / Variables (7)
#include <stdio.h>
int somme(int a){
int s=0 ; s=s+a ;
return(s) ;
}
void main(void){
int i, x ; for(i=0 ; i<4 ; i++){
printf("Rentrez la valeur de x\n ") ;
scanf("%d ", &x) ;
printf("La somme des nb rentrés est : %d\n ", somme(x)) ;
}
}
Exemple d’exécution
i valeur rentrée valeur affichée
0 5 5
1 4 4
2 10 10
3 3 3
int somme(int a){
static int s ;
s=s+a ;
return(s) ;
}
Exemple d’exécution
i valeur rentrée valeur affichée
0 5 5
1 4 9
2 10 19
3 3 22
UE programmation 3 – F. Cloppet 27
Notions Langage C / Les constantes (1)
� Définies en utilisant les macro définitions
Ex: #define TOTO 5
=> le pré-processeur remplace dans la suite du programme toute référence à cette macro (TOTO) par sa définition
=> si on veut changer la valeur de TOTO il suffit de mettre à jour la définition de la macro
UE programmation 3 – F. Cloppet 28
Notions Langage C/ Opérateurs (1)
� Opérateurs à 1, 2 ou 3 opérandes : unaires, binaires, ternaires
� Opérateurs arithmétiques et d ’affectation binaires+-*/= (affectation)% (reste de la division entière) : 10 % 8 = 2
� * et / sont prioritaires
UE programmation 3 – F. Cloppet 29
Notions Langage C / Opérateurs (2)
� Si les opérandes ne sont pas de même type => le compilateur agrandit en général l’opérande le plus étroit
Ex: l ’affectation d ’un type étroit à un type plus large n’entraîne pas de problème alors que l’inverse peut entraîner une perte d’information
UE programmation 3 – F. Cloppet 30
Notions Langage C / Opérateurs (3)
� Opérateur d’incrémentation unaire
var++;
++var;
mais (1) v1 = var++;différent de (2) v1 = ++var;
var -- => décrémente de 1 la valeur de var
� Opérateurs unaires combinés: associent une opération (+, -, *,/,%) avec une affectationvar += 10; var *=10;
UE programmation 3 – F. Cloppet 31
Notions Langage C / Opérateurs (4)
� Opérateurs binaires de comparaison> <>= =<= =!=!
� Opérateurs logiques : && (ET logique), || (OU logique)
V V F F V F V F V F F F V V V F
A B A && B A || B
UE programmation 3 – F. Cloppet 32
Notions Langage C / Opérateurs (5)
� Opérateurs binaires de traitement des bits : s’appliquent sur des entiers et des caractères
� & (ET): réalise un ET logique sur chacun des bits des 2 opérandes
27 26 25 24 23 22 21 20
ex : 6 0 0 0 0 0 1 1 0
&
10 0 0 0 0 1 0 1 0
2 0 0 0 0 0 0 1 0
UE programmation 3 – F. Cloppet 33
Notions Langage C / Opérateurs (6)
� | (OU inclusif): réalise un OU logique sur chacun des bits des 2 opérandes
27 26 25 24 23 22 21 20
ex : 1 0 0 0 0 0 0 0 1
|
121 0 1 1 1 1 0 0 1
121 0 1 1 1 1 0 0 1
UE programmation 3 – F. Cloppet 34
Notions Langage C / Opérateurs (7)
� ^ (OU exclusif): met à 0 tous les bits qui sont identiques dans op1 et op2, et à 1 ceux qui diffèrent
27 26 25 24 23 22 21 20
ex : 1 0 0 0 0 0 0 0 1^
121 0 1 1 1 1 0 0 1
120 0 1 1 1 1 0 0 0
� << : opérateur de décalage à gauche
op1<<op2 => décalage vers la gauche de op2 bits de op1, les bits de droite sont remplacés par des 0
27 26 25 24 23 22 21 20
ex : 1 0 0 0 0 0 0 0 1
1<<2 0 0 0 0 0 1 0 0 ( = 1 *4)
UE programmation 3 – F. Cloppet 35
Notions Langage C / Opérateurs (8)
� >> décalage à droite : op1 >> op2 => décalage vers la droite de op2 bits de op1
27 26 25 24 23 22 21 20
ex : 8 0 0 0 0 1 0 0 0
8>>2 0 0 0 0 0 0 1 0 ( = 8 /4)
� ~ : donne le complément à un d’une opérande de type entier (inversion de tous les bits).
27 26 25 24 23 22 21 20
ex : 28 0 0 0 1 1 1 0 0
~28 1 1 1 0 0 0 1 1 (= 227)
UE programmation 3 – F. Cloppet 36
Notions Langage C / Opérateurs (9)
( ), [], ->, . ~, ++, --, (signe +/-), *(adresse), &, sizeof(var)
*, /, % + , -<<, >>< <=, > >= = =, != & ^ | &&|| ? : tous les combinés
+ prioritaire
- prioritaire
UE programmation 3 – F. Cloppet 37
Notions Langage C / Structures de Contrôle (1)
� 3 types de structure de contrôle
a - pour exprimer des prises de décision ;
b - pour exprimer des prises de décision à choix multiples ;
c - pour répéter une suite d’instructions.
� Expression d’une prise de décision :
if-else = expression conditionnelleSi (condition est vraie) Alors
faire Action1;Sinon
faire Action2;
UE programmation 3 – F. Cloppet 38
� les if - else peuvent s’enchaîner
if(valeur == 0)
Calculer1(0) ;
else if (valeur == 1){
Calculer2(1) ;
Calculer3(1) ;
}else if (valeur == 3)
printf("La valeur est 3\n ") ;
else
printf("Valeur trop grande\n ") ;
� Opérateur ternaire ?
Var = test ? Valeur_Var si test vrai : Valeur_Var si test faux ;
Notions Langage C / Structures de Contrôle (2)
UE programmation 3 – F. Cloppet 39
� prises de décision à choix multiples : switchau cas où la valeur est égale à 2 ou à 4 afficher " + ",au cas où la valeur est égale à -2 ou à -4 afficher " - " , au cas où la valeur est égale à 0 afficher "valeur nulle ",sinon afficher "mauvaise valeur "
=> switch( valeur ){case 2 : case 4 : printf("Valeur positive\n ") ;
break ;
case -2 : case -4 : printf("Valeur négative\n ") ;
break ;
case 0 : printf("Valeur nulle\n ") ;
break ;
default : printf("Mauvaise valeur\n ") ;
}
Notions Langage C / Structures de Contrôle (3)
UE programmation 3 – F. Cloppet 40
� Répéter une suite d’instructions
� while
while(condition_vraie){
instructions ;
}
� for
for(initialisation ; condition ; instructions d’incrémentation){
instructions ;
}
Notions Langage C / Structures de Contrôle (4)
UE programmation 3 – F. Cloppet 41
� do-while
do{
instructions
}while(condition_vraie) ;
� Mots clés : break, continue
� break => permet de sortir immédiatement d’une boucle ou d’un switch
� continue => permet de passer immédiatement à une autre évaluation
de la boucle
Notions Langage C / Structures de Contrôle (5)
UE programmation 3 – F. Cloppet 42
Langage C / Les Fonctions
� la même instruction ou même suite d’instructions est utilisée plusieurs fois dans un programme
#include <stdio.h>
void main(){int x, y, z, w, minimum;
printf("Rentrez 2 valeurs entières\n");scanf("%d %d", &x, &y);minimum = (x<y) ? x : y;printf (" Le minimum de %d et %d est : %d\n",x,y, minimum);printf("Rentrez 2 valeurs entières\n");scanf("%d %d", &z, &w);minimum = ((z<w) ? z : w);printf (" Le minimum de %d et %d est : %d\n",z,w, minimum);
}
� Écriture d’un fonction
UE programmation 3 – F. Cloppet 43
Fonctions / Généralités (1)
� fonction permet de partitionner les gros traitements en tâches plus petites
� fonction permet de construire les programmes à partir de briques déjà existantes
� le découpage en fonction permet de gérer explicitement la communication entre ces modules
UE programmation 3 – F. Cloppet 44
Fonctions / Généralités (2)
� main() est une fonction particulière
TRAITEMENTPARAMETRES
VALEUR DE
RETOUR
FONCTION
UE programmation 3 – F. Cloppet 45
Fonctions / Déclaration (1)
� Déclaration d’une fonction en norme ANSI
TypeDeRetour NomDeFonction (Type1 Paramètre1, Type2 Paramètre2)
{
Déclarations des variables locales à la fonction
Liste des instructions
return ( Valeur de retour si elle existe ) ;
}
� Déclaration d’une fonction (sans la norme ANSI)
TypeDeRetour NomDeFonction (Paramètre1, Paramètre2)
Type1 Paramètre1 ;
Type2 Paramètre2 ;
{
……
}
UE programmation 3 – F. Cloppet 46
Fonctions / Déclaration (2)
� Il est interdit de déclarer une fonction à l’intérieur d’une fonction
� Valeur de retour
� doit être de type scalaire (entier, réel, caractère, etc.) pointeur ou structure mais ne peut pas être un tableau
� si pas de mot clé return
� mot clé return à l’intérieur d’une fonction
� si return est suivi d’une valeur
� si pas de TypeDeRetour
� si fonction ne renvoie pas de valeur
UE programmation 3 – F. Cloppet 47
Fonctions / Appel (1)
appel de fonction
fonction appelante fonction appelée
schéma d’un appel de fonction
UE programmation 3 – F. Cloppet 48
Fonctions / Appel (2)
� Syntaxe d’un appel de fonction avec un TypeDeRetour = void
NomDeFonction ( Liste des paramètres ) ;
� Syntaxe d’un appel de fonction avec un TypeDeRetourTypeDeRetour Variable;
Variable = NomDeFonction ( Liste des paramètres ) ;
� Une fonction doit être définie avant d’être appelée ou alors elle doit être prototypée en début de fichier
UE programmation 3 – F. Cloppet 49
Fonctions / Appel (3) – Illustration par l’exemple
#include <stdio.h>
void Somme ( int A, int B){ /* déclaration de la fonction Somme */
int C ;
C = A + B ;
printf(" Le résultat de %d + %d est %d.\n ", A, B, C) ;
return ;
}
int main( ){
int AA, BB ;
printf(" Rentrer deux nombres : " ) ;
scanf(" %d %d ", &AA, &BB) ;
Somme(AA, BB) ; /* Appel de la Fonction Somme */
return(1);
}
UE programmation 3 – F. Cloppet 50
Fonctions / Paramètres formels et effectifs (1)
� paramètre formel => apparaît dans la définition de la fonction
� paramètre effectif => objet substitué au paramètre formel lors de l’exécution de la fonction
� la correspondance entre paramètres formels et effectifs est établie selon l’ordre d’apparition dans l’en-tête de la fonction
UE programmation 3 – F. Cloppet 51
Fonctions / Paramètres formels et effectifs (2)
/* déclaration de la fonction Min */
int Min (int a, int b){
return(a<b ? a : b);
}
/* appel de la fonction Min */
x=5; y=8;
printf("%d\n",Min(x, y));
/* de même */
u=8; v=9;
printf("%d\n",Min(u, v));
UE programmation 3 – F. Cloppet 52
Fonctions / Paramètres formels et effectifs (3)
RAPPELS� Variable Locale / Globale
� la portée d'une variable dépend de l'endroit où elle déclarée
� début de fichier => variable globale
� Début d'un bloc d'instruction => variable locale
� Variable Globale� allocation de cette variable par le compilateur dans un segment
permanent de données
� domaine de visibilité => de la déclaration à la fin du programme
UE programmation 3 – F. Cloppet 53
Fonctions / Paramètres formels et effectifs (4)
RAPPELS� Variable Locale / Globale (suite)
� Variable Locale
� variable déclarée au début d'un bloc d'instructions
� accessible seulement dans le bloc où elle est déclarée
� créée lors du début de l'exécution du bloc d'instructions
� détruite à la sortie du bloc d'instructions
� paramètre formel = variable locale à la fonction
� attribut static => définition de variables rémanentes � variable conserve sa valeur entre 2 appels de la fonction� mais visible seulement dans la fonction où elle est définie
UE programmation 3 – F. Cloppet 54
Fonctions / Paramètres formels et effectifs (5)
RAPPELS� Variable Locale / Globale (suite)
� Illustration par l’exemple
int X; /* déf. variable globale */
void toto1(){
X+=10;
}
void toto2(){
int X = 5;
X*= 10;
}
void main(){
X = 20;
toto1();
printf ("%d\n", X);
toto2();
printf ("%d\n", X);
}
.....
UE programmation 3 – F. Cloppet 55
Fonctions / Passage de paramètres (1)
� 2 modes de transmission
� par valeur
� par adresse ou référence
� Passage par valeur� création d'une copie de l'objet paramètre effectif qui reçoit le nom
du paramètre formel
UE programmation 3 – F. Cloppet 56
Fonctions / Passage de paramètres (2)
X=5; Y=8;
printf("%d\n", Min(X+1 , Y ) ) ;
fonction appelantefonctionappelée
main()intMin(int a, int b)
{
return((a<b)?a:b);
}
6 8
6
a 6b 8
copie dans un emplacement
local à la fonction
X 5Y 8
5+1
Passage par valeur
UE programmation 3 – F. Cloppet 57
Fonctions / Passage de paramètres (3)
� Passage par adresse� l'adresse de la variable est passée en paramètre et non la valeur
� la fonction effectue son traitement directement sur le paramètre effectif
� 2 façons d'obtenir l'adresse d'une variable selon sa déclaration� int A; => variable A de type entier
=> &A est l'adresse de la variable A
� int *B; => B est un pointeur sur un entier <=> B représente l'adresse mémoire de la variable
=> la valeur contenue à cet emplacement mémoire est obtenue par *B;
UE programmation 3 – F. Cloppet 58
Fonctions / Passage de paramètres (4)
int X=0;
Transfo(&X);
printf("%d\n",X);
fonction appelantefonctionappelée
main()void Transfo (int *a)
{ int i;
f or(i=0; i<10;i++)(*a)++;
}
oxff15
X1O
oxff15
0
a
Passage par adresse
UE programmation 3 – F. Cloppet 59
Fonctions / Passage de paramètres (5)
� Valeur ou adresse ?� Valeur
� les paramètres effectifs ne doivent pas être modifiés
� 1 seule valeur à modifier, la valeur modifiée est renvoyée comme valeur de retour de la fonction
� Adresse� paramètres effectifs doivent être modifiés
� plusieurs valeurs doivent être renvoyées par la fonction
� pour passer un tableau en paramètres
UE programmation 3 – F. Cloppet 60
Fonctions / Récursion (1)
� En C, les fonctions peuvent être utilisées de façon récursive
� possible car la gestion des appels de fonction est assurée dans une pile
� Ex: Fonction Factorielle
0! = 1n! = n * (n - 1) * (n - 2) * .......* 2 * 1
ou n! = n * (n-1)!
UE programmation 3 – F. Cloppet 61
Fonctions / Récursion (2)
fact_1
fact_2
fact_3
n1 = 3
n2 = 2
fact_3 = n3 * fact_4
fact_1 = n1 * fact_2
fact_2 = n2 * fact_3empilement
NB : fact_1 = 1er appel de la fonction factorielle
dépilement
1
1
2
6
fact_4
n3 = 1
n4 = 0fact_4 = 1
Exemple d'exécution de la fonction Factorielle avec au départ n=3
UE programmation 3 – F. Cloppet 62
Langage C / Les Pointeurs
� pointeur = variable qui contient l'adresse mémoire où est stocké l'objet pointé (variable ou fonction)
Oxff12
Oxff13
Oxff14
Oxff15
.
.
.
.
p Oxff15
234
p est un pointeur d'entiers
� Organisation de la mémoire
pointeur = groupe de cases (2 ou 4) qui
contient l'adresse de l'objet sur lequel il
pointe
UE programmation 3 – F. Cloppet 63
Les pointeurs / Déclaration
� La déclaration d'une variable de type pointeur fait toujours intervenir le type des objets pointés
� Exemple de déclaration
int *p ;
char *pc ;
UE programmation 3 – F. Cloppet 64
Les pointeurs / Opérateurs unaires * et &
� & : fournit l'adresse de l'objet
opérande
ex : int A=234 ;&A;
� * : opérateur d'indirection ou de
déréférence
Oxff12
Oxff13
Oxff14
Oxff15
.
.
.
.
p Oxff15
234
p est un pointeur d'entiers
A
UE programmation 3 – F. Cloppet 65
Les pointeurs / Initialisation
� Il existe 2 manières d'initialiser un pointeur
� Affectation d'une adresse déjàexistante
�Allocation dynamique
Oxff12
Oxff13
Oxff14
Oxff15
.
.
.
.
p Oxff15
234
p est un pointeur d'entiers
A
UE programmation 3 – F. Cloppet 66
Les pointeurs / Allocation dynamique (1)
� Soient int *p1, *p2, *p3 ;
� Plusieurs manières d'allouer dynamiquement la mémoire
� p1 = (int *) malloc(sizeof(int)) ;
� p2 = (int*) malloc(5 * sizeof(int)) ;
� p3 = (int *) calloc(5, sizeof(int)) ;
� (int *) realloc(p3, 10*sizeof(int)) ;
UE programmation 3 – F. Cloppet 67
Les pointeurs / Allocation dynamique (2)
Oxff12
Oxff13
Oxff14
Oxff15
.
.
.
.
p1 Oxff15
p1 est un pointeur d'entiersOxff12
Oxff13
Oxff14
Oxff15
.
.
.
.
p2 Oxff17
p2 est un pointeur d'entiers
Oxff16
Oxff17
Oxff21
mallocmalloc
UE programmation 3 – F. Cloppet 68
Les pointeurs / Allocation dynamique (3)
Oxff12
Oxff13
Oxff14
Oxff15
.
.
.
.
p3 Oxff16
p3 est un pointeur d'entiers
Oxff16
Oxff17
Oxff20
0
0
0
0
0
Oxff11
Oxff12
Oxff15
.
.
p3 est un pointeur d'entiers
Oxff16
Oxff17
Oxff20
0
0
0
0
0
.
.
.
.
Oxff25
Oxff24
p3 Oxff16
.
.
calloc realloc
UE programmation 3 – F. Cloppet 69
Les pointeurs / Allocation dynamique (4)
� Fonctions malloc, calloc, realloc sont définies dans stdlib.h
� Leur type de retour est pointeur sur void => cast obligatoire
� S'il n'y a pas assez d'espace mémoire => l'allocation ne peut pas se faire => la valeur renvoyée est NULL
� NULL = valeur de pointeur constante prédéfinie� p = NULL => fait explicitement pointé p sur l'adresse 0 � 0 est la seule valeur entière que l'on peut comparer à des pointeurs
� Les espaces mémoires alloués par un malloc, un calloc ou un reallocdoivent être libérés à la fin de leur utilisation par la fonction free
free(pointeur);
UE programmation 3 – F. Cloppet 70
Les pointeurs / Opérations (1)
� Affectation de pointeurs
int *p, *p1, x=4 ; /* (I1) */
p = NULL ; /* (I2) */p1 = p; /* (I3) */p = &x; /* (I4) */
� Que vaut *p ?� Sur quoi pointe p1 ?
Oxff12
Oxff13
Oxff14
Oxff15
.
.
.
.
p
NULL
4
p et p1 sont des pointeurs d'entiers
NULL
p1
x
(I2)
(I1)
(I3)
Oxff12
Oxff13
Oxff14
Oxff15
.
.
.
.
p
NULL
4
p1
x
(I4) Oxff15
UE programmation 3 – F. Cloppet 71
Les pointeurs / Opérations (2)
� Comparaison de pointeurs� comparaison avec valeur NULL
� test d'égalité entre 2 pointeurs
� les autres relations d'ordre n'ont de sens que si on a une idée de l'implantation des objets en mémoire
� Opérations d'addition et de soustraction
Ex : int *p, x=4 ;p=&x ;p++ ;
oup+=4 ;
UE programmation 3 – F. Cloppet 72
Les pointeurs / Opérations d’incrémentation (1)
Oxff12
Oxff13
Oxff14
Oxff15
.
.
.
.
p
p pointeur d'entiers
x
Oxff12
Oxff13
Oxff14
Oxff15
p
4x
Oxff17Oxff15
4
p++
Oxff16
Oxff17
Oxff18
8y 8y
si un entier est codé sur 16bits
UE programmation 3 – F. Cloppet 73
Les pointeurs / Opérations d’incrémentation (2)
Oxff12
Oxff13
Oxff14
Oxff15
.
.
.
p
4
p pointeur d'entiers
x
Oxff12
Oxff13
Oxff14
Oxff15.
.
.
p
5x
Oxff14Oxff14
(*p)++
++ est prioritaire sur * =>
UE programmation 3 – F. Cloppet 74
Langage C / Les Tableaux (1)
� Tableau = Liste de valeurs de même type qui sont consécutives en mémoire
� Syntaxe de déclaration d'un tableau monodimensionnel
NomDeType NomTableau [Nombre_Eléments] ;
� La déclaration d'un tableau réserve la place mémoire pour tous les éléments du tableau
� Chaque élément d'un tableau est considéré comme une variable
Tab[0] Tab[1] Tab[2] Tab[3] Tab[4] Tab[5] Tab[6]
UE programmation 3 – F. Cloppet 75
Langage C / Les Tableaux (2)
� int Tab [ 10 ] ; (10 cases de taille sizeof(int))
� Tab est l’adresse du début du tableau.
� Tab [ i ] est la valeur de l'élément i du tableau.
� & Tab [ 0 ] est équivalent à Tab.
� & Tab [ i ] est l’adresse de l’élément i du tableau
UE programmation 3 – F. Cloppet 76
Les Tableaux Monodimensionnels / Initialisation
� Les tableaux définis comme variables globales ont leurs cases initialisées à 0
� 2 types d'initialisation possibles� Initialisation du tableau en bloc avec un ensemble de valeurs au
moment de la déclaration
� Initialisation par des valeurs fournies par l'utilisateur
UE programmation 3 – F. Cloppet 77
Les Tableaux Bidimensionnels / Déclaration –Initialisation (1)
� Syntaxe de déclaration d'un tableau bidimensionnel
NomDeType NomTableau[Nombre_Elts_lignes] [Nombre_Elts_colonnes] ;
Ex : int Tab[5][2];
� Intialisation avec un ensemble de valeurs lors de la déclarationint Tab[4][3] = {{1,3,5}, {2,4,6}, {3,5,7}} ;
ou 1 3 5
2 4 6
3 5 7
? ? ?
UE programmation 3 – F. Cloppet 78
Les Tableaux Bidimensionnels / Déclaration –Initialisation (2)
� Initialisation par des valeurs fournies par l'utilisateur
int Tab[4] [3], i, j, valeur ;
for(i = 0 ; i < 4 ; i++)
for(j=0 ; j < 3 ; j++){
printf("Entrer la valeur n° %d, %d : ", i,j) ;
scanf("%d",&valeur) ;
Tab[i] [j] = valeur ;
}
UE programmation 3 – F. Cloppet 79
Tableaux / Passage d’un tableau ou d’un élément en paramètres
int Tab[10], NbTab=10 ;
void maFonction1(int A) ;
void maFonction2(int A[ ], int Nb) ;
void maFonction3(int *A) ;
Les appels de fonction seront de la forme :
maFonction1(Tab[5]) ;
maFonction2(Tab, NbTab) ;
maFonction3(&Tab[5]) ;
UE programmation 3 – F. Cloppet 80
Tableaux / Passage d’un tableau 2D en paramètres
� le nombre d'éléments de la 2ème composante est obligatoire
int Tab2[10][20], Nb_lig=10, Nb_col=20 ;
void Fonction2(int Tab2[ ] [20], int nb_ligne, int nb_colon) ;
Appel de la fonction
Fonction2( Tab2, Nb_lig, Nb_col) ;
� Pour tester l'égalité de 2 tableaux, il faut faire une comparaison élément par élément
UE programmation 3 – F. Cloppet 81
Langage C / Les Tableaux de caractères (1)
� 'a' est un caractère => type char� "Bonjour à vous tous" est une chaîne de caractères => tableau de
caractères
� Syntaxe de déclarationchar NomChaine[Nb_Elts] ;
Ex : char Chaine[10] ; /* déclaration d'un tableau de 10 caractères de nom Chaine */
� En C, une chaîne de caractères se termine toujours par '\0'Si la chaîne de caractères Chaine est égale à "Bonjour"
B O N J O U R \0
Chaine
UE programmation 3 – F. Cloppet 82
Les tableaux de caractères / Initialisation
� Au moment de la déclarationchar ch[] = " BONJOUR "; char ch[] = {’B’,’O’,’N’,’J’,’O’,’U’,’R’,’\0’} ;
� Par des valeurs fournies par l'utilisateurchar ch[10] ;
for(i = 0 ; i < 9 ; i++) /* lecture caractère par caractère */
ch[i] = getch() ;
ch[i] = ‘\0’ ;
ou
scanf("%s ",ch) ; /* lecture en bloc de la chaîne de caractères */
� On ne peut pas écrire
char ch[10];
ch = "Bonjour" car ch est une adresse non réassignable
UE programmation 3 – F. Cloppet 83
Les tableaux de caractères / Fonctions prédéfinies (1)
� Fonctions d'entrée / sortie :
char ch[100], ch1[100], ch2[100] ;
int toto, x=4 ;
scanf ("%s ", ch) ;
sscanf (ch1, "%s ", ch2) ;
sprintf(ch, "le nombre est %d\n ", x) ;
gets(ch) ;
puts(ch) ;
UE programmation 3 – F. Cloppet 84
Les tableaux de caractères / Fonctions prédéfinies (2)
� Fonctions de traitement des chaînes de caractères :�définies dans la librairie string.h
� strcpy :
strcpy(ch1, ch2) ;
char ch[10] ;
strcpy(ch, "BONJOUR ! ") ;
� strcat, strcmp, strchr, strlen
char ch[100], ch1[100], ch2[100] , c, *c1;
int toto;
UE programmation 3 – F. Cloppet 85
� strcat :
strcat(ch1, ch2) ;
strcpy(ch1, "Bonjour") ;
strcat(ch1, " à vous") ;
printf("%s", ch1) ; => Bonjour à vous
� strcmp :
toto = strcmp(ch1, ch2) ;
strcpy(ch1, "Bonjour") ; strcpy(ch2, "Bonsoir") ;
toto=strcmp(ch1,ch2) ;
printf("%d\n", toto) ;
Les tableaux de caractères / Fonctions prédéfinies (3)
UE programmation 3 – F. Cloppet 86
� strchr :
strchr(ch, c) ;
strcpy(ch1, "Bonjour") ;
c1 = strchr(ch1, 'o') ;
printf("%s\n", c1) ;
� strlen :
toto = strlen(ch) ;
strcpy(ch1, "Bonjour") ;
toto = strlen(ch1) ;
printf(" longueur : %d\n", toto) ; => 7
Les tableaux de caractères / Fonctions prédéfinies (4)
UE programmation 3 – F. Cloppet 87
Langage C / Synthèse Tableaux -Tableaux de caractères - pointeurs (1)
� En C, les pointeurs et les tableaux sont très fortement liés.
int tab[10] ;
int *ptab ;
ptab = &tab[0] ;
ptab++ ;
ptab + i ; *(ptab + i);
ptab[i];
UE programmation 3 – F. Cloppet 88
Langage C / Synthèse Tableaux -Tableaux de caractères - pointeurs (2)
Soient
int A ;
int tab[10] ;
int *B, *ptab ;
char car ;
char chaine[10] ;
char *ch1, *ch2 ;
� Que représentent A, tab, tab[0], B, ptab, car, chaine, chaine[0], ch1, ch2 ?
UE programmation 3 – F. Cloppet 89
Langage C / Synthèse Tableaux -Tableaux de caractères - pointeurs (3)
� A est une variable …
� tab est l’adresse de …
� B (et ptab) sont des …
� car est une variable …
UE programmation 3 – F. Cloppet 90
Langage C / Synthèse Tableaux -Tableaux de caractères - pointeurs (4)
� chaine est …
� chaine[0] …
� ch1 et ch2 sont des …
UE programmation 3 – F. Cloppet 91
Langage C / Synthèse Tableaux -Tableaux de caractères - pointeurs (5)
� Que représentent les suites d'instructions suivantes (avec les déclarations de variables précédentes)?
(1) A =256 ;B= &A ;
(2) ptab = tab ;
(3) ptab = &tab[5] ;
ptab++ ;
(4) strcpy(chaine, "Bonjour !") ;
ch1 = chaine ;
ch2 = &chaine[2] ;
ch2++ ;
� Peut on écrire chaine = ch2 ?
UE programmation 3 – F. Cloppet 92
Langage C / Synthèse Tableaux -Tableaux de caractères - pointeurs (6)
� A = 256 ;
� B = &A ;
� ptab = tab ;
� ptab = &tab[5] ;
ptab ++ ;
UE programmation 3 – F. Cloppet 93
Langage C / Synthèse Tableaux -Tableaux de caractères - pointeurs (7)
� strcpy(chaine, "BONJOUR ! ") ;
� ch1 = chaine ;
� ch2 = &chaine[2] ;
� ch2 ++ ;
� chaine = ch2 ;
UE programmation 3 – F. Cloppet 94
Langage C / Synthèse Tableaux -Tableaux de caractères - pointeurs (8)
� Ces séquences d'instructions sont elles correctes ?
(1) (2)
int A = 20, *B ;
B = &A ;
*B = 200 ;
(3) (4)
char ch[20] ;
ch= "Bonjour";
UE programmation 3 – F. Cloppet 95
Langage C / Synthèse Tableaux -Tableaux de caractères - pointeurs (9)
UE programmation 3 – F. Cloppet 96
Langage C / Synthèse Tableaux -Tableaux de caractères - pointeurs (10)
� (3) char ch[20] ;
ch= "Bonjour" ;
(4) char *ch1;
ch1="Bonjour" ;
UE programmation 3 – F. Cloppet 97
Langage C / Synthèse Pointeurs / Tableaux de pointeurs (1)
� Les pointeurs sont des variables
� Il est possible de les stocker dans des tableaux
�Ex : char *tab[4] = {"Lundi", "Mardi","Mercredi","Samedi"} ;
� Les 4 éléments du tableau sont des pointeurs de caractères
� Avantage par rapport à un tableau 2D
l n du
m r da
m r ce
s m ea
i
r
d
tab i
e d i
i
UE programmation 3 – F. Cloppet 98
Langage C / Les structures (1)
� Une structure rassemble plusieurs entités qui peuvent avoir des types différents
� Structure permet de traiter un groupe de variables liées entre elles comme un tout et non comme des entités séparées.
� Notion différentes de la notion de tableau qui permet de regrouper des objets de même type
UE programmation 3 – F. Cloppet 99
Les structures / Déclaration (1)
� Syntaxe
struct NomStructure{/* NomStructure = étiquette de la structure */type1 champ1 ;type2 champ2 ;.....
} ;
� mot clé struct indique une déclaration de structure constituée d'une liste de déclaration entre accolades
� Exemple
UE programmation 3 – F. Cloppet 100
Les structures / Déclaration (2)
� Déclaration d'une structure permet de définir un modèle objet mais n'engendre aucune réservation mémoire
� Le modèle défini peut être utilisé dans une déclaration de variable
� Ex : Déclaration d'une variable nommée UnProduit de type structproduit
struct produit UnProduit ;
� Ex : Déclaration d'un pointeur de struct produit
struct produit *PtrProduit;
UE programmation 3 – F. Cloppet 101
Les structures / Déclaration (3)
� Définition du type structure défini comme un type utilisateur
� utilisation de l'opérateur typedef
� syntaxe :typedef spécification_de_type nouveau_nom_de_type ;
� Ex :
typedef struct produit { /* Nom de la structure */
int reference, categorie ;
char *nom, *provenance ;
} produit, *Pproduit ; /* Noms des nouveaux types */
� Déclaration d'un produit et d'un pointeur sur un produit
� produit UnProduit ;
� Pproduit PtrProduit;
UE programmation 3 – F. Cloppet 102
Les structures / Initialisation
� Au moment de la déclaration� Variable du type de la structure peut être initialisée par une liste
de valeurs constantes correspondant à chacun des membres
Ex:
produit UnProduit = {15, 3, "toto", "Inde"} ;
� Avec des valeurs rentrées par l'utilisateur
� appel à une fonction (définie dans le programme) qui remplira les champs de la structure et retournera la structure initialisée.
UE programmation 3 – F. Cloppet 103
Les structures / Accès à un champ d’une structure (1)
� Si la variable est du type de la structure� opérateur •� Ex : Accès aux valeurs stockées dans les champs d'une variable de type
produit
produit UnProduit = {15, 3, "toto", "Inde"} ;char *NomDuProduit ;int NumDuProduit;
� Ex : remplissage des champs d'une variable de type produit ;
UE programmation 3 – F. Cloppet 104
Les structures / Accès à un champ d’une structure (2)
� Si la variable est du type pointeur sur la structure
� opérateur : ->
� Ex : Accès aux valeurs stockées dans les champs d'une variable de type
pointeur sur produit
Pproduit PtrProduit ;
char *NomDuProduit ;int NumDuProduit;
UE programmation 3 – F. Cloppet 105
Les structures / Tableaux de structures
� Si l'on veut compter le nombre d'occurrences de chaque mot d'une liste de mots clés : => 2 solutions
� gérer 2 tableaux en parallèle : char *liste_motcle[NB] ; /* NB supposé défini par 1 #define */int compteur[NB] ;
� utiliser un tableau de structure : typedef struct cle{
char *mot ;int compt ;
}cle ;
cle liste_cle[NB] ; /* NB supposé défini par 1 #define */
l'accès au 3ème mot clé :l'accès à son nombre d'occurrences :
UE programmation 3 – F. Cloppet 106
Les structures / Composition de structures
� Une structure permet de définir un type qui peut être utilisé
� dans une déclaration de variable� comme type d'un des champs d'une autre structure =>
composition
� Ex :
UE programmation 3 – F. Cloppet 107
Les structures / Struct. Récursives ou autoréférentielles
� structure récursive quand un des champs est du type de la structure qu'on est en train de définir
� Il est INTERDIT de définir une structure contenant une instance d'elle-même MAIS il n'est pas interdit qu'un champ soit du type pointeur sur la structure.
� Ex : typedef struct Individu{ typedef struct Individu{
char nom[40] ; char nom[40] ;int age ; int age ;struct Individu *pere, struct Individu pere,
*mere ; mere ;}Individu ; }Individu ;
écriture correcte écriture incorrecte
Avant de remplir les champs de pere et mere
=> allouer de l'espace
UE programmation 3 – F. Cloppet 108
Langage C / Les Unions (1)
� Un objet de type union pourra contenir à des instants différents des objets de type et de taille différente.
� L'espace mémoire réservé correspond à l'espace mémoire nécessaire pour stocker le plus grand des types
� Définition d'une union est analogue à la définition d'une structureunion Cat{ /* la catégorie peut être soit de type int soit de type char * */
int Icat ;
char *Ccat ;
} ;
� Un objet de type structure est composé de
� Un objet de type union est composé d'un
UE programmation 3 – F. Cloppet 109
Langage C / Les Unions (2)
� L'accès aux membres d'une union se fait comme pour les structures� On peut placer des unions à l'intérieur de structures
typedef struct produit {
int reference, TypeCat ; /* TypeCat = 0 : int, TypeCat = 1 : char */
union cat{ /* Nom de l’union */
int Icat ;
char *Ccat ;
} Cat ; /* Champs Cat de type Union cat */
char *nom, *provenance ;
} produit, *ptproduit ;
produit P ; …. /* On suppose les champs de P remplis */
UE programmation 3 – F. Cloppet 110
Langage C / Les Énumérations (1)
� n'existent pas dans le standard défini par Kernighan et Ritchie
� mais admises par de + en + de compilateurs
� une déclaration d'énumération permet de définir un modèle d'entiers dont les valeurs sont notées par des constantes symboliques
� syntaxe :enum NomIdentificateur { liste de valeurs symboliques } ;
� Ex :
UE programmation 3 – F. Cloppet 111
� Intérêt : facilite la compréhension et la maintenance du programme
� Ex :typedef enum Couleur{VERT,ORANGE,ROUGE} CouleurFeu;CouleurFeu Feu;
Feu = ORANGE ;printf("Couleur du feu : %d\n", Feu) ; => Couleur du feu : 1
switch(Feu){case VERT: printf("passez\n");
break;case ORANGE: printf("ralentissez\n");
break;case ROUGE: printf("arrêtez vous\n");
break;}
Langage C / Les Énumérations (2)
UE programmation 3 – F. Cloppet 112
Langage C / Les Fichiers (1)
� Les fichiers permettent de conserver de façon permanente des informations dans la mémoire de masse d’un ordinateur.
� Ce sont des objets qui sont manipulés de manière linéaire, du début jusqu’à la fin.
� La méthode classique d’utilisation des fichiers est :
• Ouverture d’un fichier.
• Opération sur le fichier (lire, écrire, ajouter).
• Fermeture du fichier.
� FILE est le type d'un fichier => librairie <stdio.h>
ex de déclaration : FILE *fich;
UE programmation 3 – F. Cloppet 113
Les Fichiers / Ouverture
� fonction fopen
FILE *fopen(char *chemin, char *mode d'accès)renvoie NULL si erreur lors de la tentative d'ouverture
modes (fichiers de type texte)"r""w"
"a"pour les fichiers de type binaire ….
ex : FILE *fich ;fich = fopen("toto.txt", "r") ;
ou fich=fopen("d :\\tmp\\toto.txt", "r");
UE programmation 3 – F. Cloppet 114
Les Fichiers / Fermeture
� fonction fcloseint fclose( FILE *fic) => ferme le fichier pointé par fic
� Ex. de séquence ouverture / fermeture de fichierFILE *Fic = NULL ;
charchar NomFichierNomFichier[200] [200] ;;.......Fic = fopen(NomFichier, "w ") ;
if(Fic == NULL){
printf("Erreur à l’ouverture du fichier %s ", NomFichier) ;
return ;
}
…… traitement ……
fclose(Fic) ;
UE programmation 3 – F. Cloppet 115
Les Fichiers / Opérations (1)
� Entrées / Sorties de caractères� char fgetc(FILE *fic)
� char fputc(char c, FILE *fic)
� Ex : Affichage de tous les caractères d'un fichier sur la sortie standard
char c ;
FILE *Fic ;
.......
while((c = fgetc(Fic)) != EOF)
printf("%c",c) ;
UE programmation 3 – F. Cloppet 116
Les Fichiers / Opérations (2)
� Entrées / Sorties avec formatage (sur fichiers en mode texte)� fscanf
ex : Lecture de deux entiers séparés par un espace, puis passage à la ligne.
� fprintf
ex : Écriture de deux entiers séparés par un espace, puis passage à la ligne.
UE programmation 3 – F. Cloppet 117
Les Fichiers / Opérations (3)
� Entrées / Sorties de blocs (sur fichiers ouverts en mode binaire)
� fread
size_t fread(type *ptr, size_t tailleObj, size_t NbObjet, FILE *Fic)
� fwrite
size_t fwrite(type *ptr, size_t tailleObj, size_t NbObjet, FILE *Fic)
UE programmation 3 – F. Cloppet 118
Les Fichiers / Opérations (4)
� Lecture de 40 caractères du fichier pointé par Fic dans le tableau tabFILE*Fic ;
char tab[40] ;
........
fread(tab, sizeof(char), 40, Fic) ;
� Ecriture de 40 caractères du tableau tab, dans le fichier pointé par Fic FILE*Fic ;
char tab[40] ;
........
fwrite(tab, sizeof(char), 40, Fic) ;
UE programmation 3 – F. Cloppet 119
Les Fichiers / Opérations (5)
� fseek => positionnement du marqueur de fichierint fseek (FILE *flux, long offset , int mode)
fseek fait pointer le pointeur de fichier associé au flux
flux offset octets plus loin.
mode peut prendre les valeurs 0, 1, 2 selon que le
déplacement doit être :
� 0 : par rapport au début du fichier
� 1 : par rapport à la position courante
� 2 : par rapport à la fin du fichier.
UE programmation 3 – F. Cloppet 120
Les Fichiers / Opérations (6)
� ftell => retourne la position du marqueur de fichier� ces 2 fonctions sont surtout utiles pour gérer des fichiers avec des structures (du type fiches)
� rewind => met le marqueur en début de fichier
� remove => destruction d'une fichier
� rename => change le nom d'un fichier
UE programmation 3 – F. Cloppet 121
Langage C / Le pré-processeur (1)
� Le préprocesseur est un programme standard qui effectue des modifications sur un texte source.
� Il modifie le source d'après les directives données par le programmeur, et introduites par le caractère #.
� La directive du préprocesseur commence par un # et se termine par la fin de ligne.
UE programmation 3 – F. Cloppet 122
Langage C / Le pré-processeur (2)
� Le préprocesseur peut rendre plusieurs services :
� l'inclusion de fichier
� la substitution de symboles
� le traitement de macro-instructions
� la compilation conditionnelle
UE programmation 3 – F. Cloppet 123
Langage C / Le pré-processeur (3)
� L'inclusion de fichier source� La commande #include du préprocesseur permet d'inclure des
fichiers source.� Lorsque le préprocesseur rencontre la commande #include, il
remplace cette ligne par le contenu du fichier.� Syntaxe
UE programmation 3 – F. Cloppet 124
Langage C / Le pré-processeur (4)
� Substitution de symboles
� #define nom reste-de-la-ligne
� le préprocesseur remplace toute nouvelle occurrence de nom par reste-de-la-ligne dans toute la suite du source.
� Exemple :
UE programmation 3 – F. Cloppet 125
Langage C / Le pré-processeur (5)
� Macro-instructions� Une définition de macro-instruction permet une substitution de
texte paramétrée par des arguments.
� Syntaxe :� #define nom(liste_parametres_formels) reste_de_la_ligne
� La liste de paramètres formels est une liste d'identificateurs séparés par des virgules.
� Il n'y a pas d'espace entre le nom et (
� Toute occurrence ultérieure de nom sera un appel de la macro et devra avoir la forme :
� nom(liste_parametres_effectifs)
UE programmation 3 – F. Cloppet 126
Langage C / Le pré-processeur (6)
� Macro-instructions
� Lors de l'appel, le préprocesseur remplace
� l'ensemble nom de la macro et liste des paramètres effectifs "parenthésés "
par � la chaîne reste_de_la_ligne dans laquelle toutes les occurrences des
paramètres formels sont remplacées par les paramètres effectifs.
UE programmation 3 – F. Cloppet 127
Langage C / Le pré-processeur (7)
� Macro-instructions� Exemple :
� borne_inferieure = min(i,j); Remplacé par borne inferieure = ((i)<(j) ? (i):(j))� borne_superieure = max(i,j); Remplacé par borne superieure = ((i)>(j) ? (i):(j))
UE programmation 3 – F. Cloppet 128
Langage C / Le pré-processeur (8)
� Macro-instructions
� Si on ne met pas de parenthèses sur les paramètres formels, il peut y avoir des erreurs.
� On recommande donc de toujours utiliser deux règles dans la définition d'une macro-instruction :
� parenthéser les occurrences des paramètres formels;� parenthéser le corps complet de la macro.
UE programmation 3 – F. Cloppet 129
Langage C / Le pré-processeur (9)
� Macro-instructions
� Attention aux effets de bord inattendus sur les paramètres effectifs.
� Exemple : #define carre(a) ((a)*(a))
� L'utilisation de carre(x++) sera transformé en ….
UE programmation 3 – F. Cloppet 130
Langage C / Le pré-processeur (10)
� Compilation conditionnelle
� Les mécanismes de compilation conditionnelle ont pour but de compiler ou d'ignorer des ensembles de lignes, le choix étant basé sur un test exécuté à la compilation.
UE programmation 3 – F. Cloppet 131
Langage C / Le pré-processeur (11)
� Compilation conditionnelle : #if� Syntaxe :
#if expressionensemble-de-lignes
#endif
� ensemble-de-lignes est une suite de lignes quelconques.
� L'évaluation de expression a lieu au moment de la compilation.
� Si expression est vraie ensemble-de-lignes est compilé.
UE programmation 3 – F. Cloppet 132
Langage C / Le pré-processeur (12)
� Compilation conditionnelle : #if #else #elif
UE programmation 3 – F. Cloppet 133
Langage C / Le pré-processeur (13)
� Compilation conditionnelle� Exemple
#include <stdio.h>
#define AFFICHE 0
int main(){
int x = 10;
x = x +10;
#if AFFICHE
printf("x: %d\n", x);
#endif
printf("fin du programme\n");
return(1);
}
UE programmation 3 – F. Cloppet 134
Langage C / Le pré-processeur (14)
� Compilation conditionnelle� Exemple
#include <stdio.h>
#define AFFICHE 1
int main(){
int x = 10;
x = x +10;
#if AFFICHE
printf("x: %d\n", x);
#endif
printf("fin du programme\n");
return(1);
}
UE programmation 3 – F. Cloppet 135
Langage C / Le pré-processeur (15)
� #ifdef� Ces commandes permettent de tester si un symbole a été défini
par la commande #define
� Exemple :
UE programmation 3 – F. Cloppet 136
Langage C / Le pré-processeur (16)
� #ifndef
#ifndef (NOM) ou #if !defined (NOM) instructions instructions
#endif #endif
� Exemple
UE programmation 3 – F. Cloppet 137
Langage C / Le pré-processeur (17)
� L'opérateur defined est un opérateur spécial : il ne peut être utilisé que dans le contexte d'une commande #if ou #elif.
� Il permet d'écrire des tests portant sur la définition de plusieurs symboles alors que #ifdef ne peut en tester qu'une.
� Syntaxe :defined nom ou defined(nom)
� Exemple : #if defined(SYMBOLE1) || defined(SYMBOLE2)
UE programmation 3 – F. Cloppet 138
Langage C / Compilation séparée (1)
� Compilation simple (Rappel)
� Phase de compilation :
� Phase d'édition de liens :
.c .o
Compilation Édition de liens
fichier.c fichier.o prog.exe
source code objet programme exécutable
UE programmation 3 – F. Cloppet 139
Langage C / Compilation séparée (2)
� Compilation séparée
� Lorsqu'un programme devient grand, il devient intéressant � de diviser le code source en plusieurs fichiers .c,
� De plus, vous pouvez regrouper un ensemble de fonctions et l'isoler dans un fichier source ce qui permet de pouvoir les réutiliser dans d'autres projets.
UE programmation 3 – F. Cloppet 140
Langage C / Compilation séparée (3)
� Compilation séparée
.c
.o
Compilation Édition de liens
fichier.c
fichier.o
prog.exe
source code objet programme exécutable
.h
fichier.h
.c
main.c
.omain.o
UE programmation 3 – F. Cloppet 141
Langage C / Compilation séparée (4)
� Un fichier objet (.o) est un fichier contenant :
� le code compilé du source correspondant
� une table des variables et des fonctions exportées définies dans le source
� une table des variables et des fonctions qui sont utilisées mais non définies
UE programmation 3 – F. Cloppet 142
Langage C / Communication entre modules (1)
� 1 Application peut être conçue comme une collection de modules
� module = unité de programme mémorisée dans un fichier, qui constitue une unité de compilation
� les unités sont compilées séparément
�tâche de l'éditeur de liens = …
�1 protocole est nécessaire pour la communication entre les divers modules
UE programmation 3 – F. Cloppet 143
� Règles de Communication(1)� 1 variable ou 1 fonction est partagée entre 2 modules quand
elle est utilisée dans ces 2 modules
� Seules les variables globales à un module peuvent être partagées
� Toute fonction peut-être partagée
� 1 variable ou fonction partagée doit faire l'objet d'une déclaration d'importation dans le module où elle est utilisée mais non définie
�mot clé extern
Langage C / Communication entre modules (2)
UE programmation 3 – F. Cloppet 144
� Règles de Communication(2)
� Déclaration d'importation d'une variable
extern int X ;
� Déclaration d'importation d'une fonction
extern void toto() ; ou extern void toto(int) ;
Langage C / Communication entre modules (3)
UE programmation 3 – F. Cloppet 145
Module 1 Module 2
int v=23;
int x=25;
extern int Val;
extern int Fonct();
main(){
....
}
int Val=100;
int Fonct(int P){
extern int v;
int j;
........
}
int Toto(float z){
.......
}
extern int Fonct(int);
Langage C / Communication entre modules (4)
int y=6, res;
res=Fonct(y);
UE programmation 3 – F. Cloppet 146
� Protection de données � Cas où on ne désire pas que les symboles définis dans un module soient
accessibles depuis l'extérieur d'un module
� Conflit entre variables souvent quand plusieurs personnes interviennent sur un projet et ne se concertent pas pour les noms
� Pour rendre un identificateur non exportable => attribut static
Ex :
Langage C / Communication entre modules (5)
UE programmation 3 – F. Cloppet 147
� Fichier d'en-tête� En C un module doit être implanté à l'aide de deux fichiers :
� les définitions dans un fichiers source (.c)
� les déclarations des variables et fonctions exportables (utilisables dans d'autres modules) dans un fichier d'en-tête (.h)
� Un module utilisant les fonctions et/ou les variables d'un autremodule doit "inclure" le fichier d'en-tête de celui-ci (pour avoir les déclarations).
Langage C / Communication entre modules (6)
UE programmation 3 – F. Cloppet 148
� Fichier d'en-tête (suite)� Exemple
#include <stdio.h>
extern void empiler(double);
void main(void){
double x ;
.......
empiler (50) ;
....
}
main.c
#include <stdio.h>
#include "pile.h"
void empiler(double y){
.......
}
double depiler (void){
....
}
pile.c
void empiler (double);
double depiler(void) ;
pile.h
Langage C / Communication entre modules (7)
UE programmation 3 – F. Cloppet 149
� Inclusion Conditionnelle � pour éviter d'inclure plusieurs fois le contenu d'un fichier entete.h� Placer le contenu du fichier à l'intérieur d'une instruction conditionnelle
� Ex :#ifndef ENTETE#define ENTETE/* on met ici le contenu de entete.h */
#endif
expression ENTETE vaut 0 si le fichier n'a pas été inclus1 s'il a déjà été inclus
Langage C / Communication entre modules (8)
UE programmation 3 – F. Cloppet 150
main.c pile.c pile.h
Langage C / Communication entre modules (9)
UE programmation 3 – F. Cloppet 151
� Fichier d'en-tête (suite)� Exemple
main.c pile.c pile.h
Problème: empiler et depiler doivent être vues comme étant définies dans un autre fichier source=>prototypes précédés de extern
Langage C / Communication entre modules (10)
UE programmation 3 – F. Cloppet 152
Langage C / Communication entre modules (11)
#include <stdio.h>
#include "pile.h"
void main(void){
double x ;
.......
empiler (50) ;
x = depiler();
....
}
main.c
#include <stdio.h>
#define PILE
#include "pile.h"
void empiler(double y){
.......
}
double depiler (void){
....
}
pile.c pile.h
void empiler (double);
double depiler(void);
extern void empiler (double);
extern double depiler(void);
UE programmation 3 – F. Cloppet 153
Langage C / Arguments de la ligne de commandes (1)
� Langage C offre des mécanismes qui permettent d'intégrer
parfaitement un programme C dans l'environnement hôte
� ex: environnement orienté ligne de commande (Unix, Linux)
� Programme C peut recevoir de la part de l'interpréteur de
commandes qui a lancé son exécution, une liste d'arguments
� Liste = ligne de commande qui a servi à lancer l'exécution du
programme
� Liste composée
� Du nom du fichier binaire contenant le code exécutable du programme
� des paramètres de la commande
UE programmation 3 – F. Cloppet 154
Langage C / Arguments de la ligne de commandes (2)
� Fonction main reçoit tous ces éléments de la part de
l’interpréteur de commandes
� 2 paramètres
� argc (argument count)
� argv (argument vector)
UE programmation 3 – F. Cloppet 155
Langage C / Arguments de la ligne de commandes (3)
� Si on veut analyser la ligne de commande, l’entête de la fonction
main est alors