Département Génie Civil & Département Mécanique Énergétique Programmation Structurée Langage C Laurence.Bergougnoux@univ-amu.fr http://iusti.polytech.univ-mrs.fr/~bergougnoux/
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 2
L'équipe enseignante Laurence BERGOUGNOUX François GUILLARD Christian MARIANI Fabien PETITPAS Jérôme VICENTE Bureau 208 Bureau 242 Bureau 321 Bureau 319B Bureau 326 Prenom.Nom@polytech.univ-mrs.fr ou Prenom.Nom@univ-amu.fr Avec la participation de Jean-Luc FIRPO Progr. struct. - C Introduction 3
Organisation de l'enseignement ME GC 14h cours 14h TD 20h TP 14h cours 20h TD 20h TP La semaine 51 Mini projet & oral + Contrôle continu + Examen ME Progr. struct. - C Projet & oral + Contrôle continu + Examen GC Introduction Maxime Alarcon & Yassine El Khatari 4
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 5
En pratique : le 1er TD c'est GC 3.1, Mercredi 09/10, 15h30 GC 3.2, Mercredi 09/10, 13h30 ME ME ME ME 3.1, Lundi 07/10, 10h 3.2, Lundi 07/10, 13h30 3.3, Vendredi 11/10, 10h 3.4, Mardi 08/10, 13h30 Progr. struct. - C Introduction 6
Plan du cours 1. 2. 3. 4. 5. 6. 7. 8. 9. Introduction Les bases du langage C Les pointeurs et les tableaux Les fonctions Les types utilisateurs La gestion de fichiers La programmation modulaire L'allocation dynamique de mémoire Les listes chaînées
Les objectifs de ces cours, TD, TP Apprendre à résoudre un problème grâce à un algorithme, Apprendre à programmer en C à des débutants de manière efficace, Initier à la programmation par gestion d'évènements, Pratiquer un environnement de développement largement utilisé dans l'industrie, Être une introduction au C++... Progr. struct. - C Introduction 8
Progr. struct. - C Introduction 9
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 10
Qu'est-ce qu'un Algorithme? Un algorithme énonce une résolution sous la forme d une série d opérations à effectuer. données (entrées) ingrédients Progr. struct. - C Algorithme Recette de cuisine Quelques généralités résultat (sorties) plat 11
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. 1) 2) 3) 4) 5) 6) 8) Recette du gâteau à la crème de marrons : Préchauffer le four à 180 C Faire fondre le chocolat et le beurre Casser 3 œufs et les battre Ajouter la crème de marrons, et mélanger Incorporer le chocolat fondu à la préparation Beurrer un moule à gâteau et y verser la préparation Faire cuire 35 min à 180 C Progr. struct. - C Quelques généralités 12
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 13
Quelques Langages Par ordre chronologique : Assembleur 68000, 8086 Fortran, Cobol Basic, Pascal, Langage C Langages Objets : C++, Java, C#, http://www.scriptol.fr/programmation/langages-populaires.php Progr. struct. - C Quelques généralités 14
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 15
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 Compilation Source Progr. struct. - C Fichier Objet Éditeur de liens Quelques généralités Fichier Exécutable 16
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 Quelques généralités 17
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 18
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 19
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 20
Premier Programme en langage C sous LabWindows/CVI source_1.c Progr. struct. - C 1er programme 21
Le fichier Source en C source_1.c #include <stdio.h> // fichier en-tête ou header où se trouve la définition de printf() int main() //Fonction ou bloc principal { printf("bienvenue a POLYTECH Marseille \n"); return(0); } Progr. struct. - C 1er programme 22
Département Génie Civil & Département Mécanique Énergétique Les bases du langage C 1. 2. 3. 4. Les Les Les Les Prog. Struct. - C types de données variables opérateurs structures conditionnelles Les bases 23
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 24
Les types de données Qu'est-ce qu'un type? définit une convention de codage de l'information dans un emplacement de taille préfixée 1 nombre : entier ou réel 1 Variable en C 1 pointeur : adresse Prog. Struct. - C 1. Les types de données 25
Les nombres entiers Types prédéfinis Signification Taille (octet) Plage de valeurs char Caractère 1-128 à 127 unsigned char Caractère non signé 1 0 à 255 short int Entier court 2-32 768 à 32 767 unsigned short int Entier court non signé 2 0 à 65 535 int Entier 4-2 147 483 648 2 147 483 647 unsigned int Entier non signé 4 0 à 4 294 967 295 long int Entier long 4-2 147 483 648 à 2 147 483 647 unsigned long int Ent. long non signé 4 0 à 4 294 967 295 Prog. Struct. - C 1. Les types de données à 26
Les nombres réels Types prédéfinis float double long double Prog. Struct. - C Signification Taille (octet) Réel simple précision 4 Réel double précision Flottant double long Plage de valeurs 3,4 x 10-38 à 3,4 x 1038 8 1,7 10-308 à 1,7 10308 10 3,4 10-4932 à 3,4 104932 1. Les types de données 27
Codage binaire des nombres entiers 1970 = 1024 + 512 + 256 + 128 + 32 + 16 + 2 = 210 + 29 + 28 + 27 + 25 + 24 + 21 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 00 00 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1110110010 des nombres réels 197,75 = 128 + 64 + 4 + 1, 0.5 + 0.25 = 27 + 26+ 22 +20, 2-1 + 2-2 = 11000101,11 signe = 1,100010111 x 27 exposant = 7+127=134=1000 0110 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 0 1 00 0 0 11 0 1 0 0 0 1 0 1 1 1 0 0 0 0 0000000000 exposant mantisse Prog. Struct. - C 1. Les types de données 28
Les pointeurs Type *pointeur Signification adresse Prog. Struct. - C Taille (octet) Plage de valeurs 2 (sur 16 bits) 0x0000 à 0xFFFF 4 (sur 32 bits) 0x00000000 à 0xFFFFFFFF 1. Les types de données 29
Leur nom : Les variables Contient 32 caractères max Commence par une lettre Ne peut être un des mots réservés du C auto default float register struct volatile break do for return switch while case double goto short typedef char else if signed union const enum int sizeof unsigned long static void continue extern Prog. Struct. - C 2. Les variables 30
Les variables : leurs noms identificateur Correct incorrect Raison Variable Nom de Variable comporte des espaces Nom_De_Variable 123Nom_De_Variable nom_de_variable toto@mailcity.com nom_de_variable_123 Nom-de-variable _707 goto MAJUSCULE Prog. Struct. - C commence par un chiffre caractère spécial @ signe - interdit nom réservé minuscule 2. Les variables 31
La déclaration de variables 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); } Prog. Struct. - C 2. Les variables 32
Les constantes #include <stdio.h> //Directive du pré processeur #define PI 3.14159 int main() { float a; //Déclaration d'une constante const int douze=12; a = douze*pi; } Prog. Struct. - C 2. Les variables 33
Ce que vous allez faire le + souvent : Afficher à l'écran une variable int Nb_vies=3; printf("pour afficher à l\' écran\n"); printf("il vous reste %d vies",nb_vies); Saisir au clavier le contenu d'une variable int age; printf("entrez votre age :"); scanf("%d",&age); char %c int Prog. Struct. - C %d float %f double %lf 2. Les variables 34
Les 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 35
Les opérateurs de calcul Opérateur Exemple Si Si int x=10; float x=10.0; + d'addition x=x+3; 13 13.0 - de soustraction x=x-3; 7 7.0 * de multiplication x=x*3; 30 30.0 / de division x=x/3; 3 3.3333333 % modulo x=x%3; 1 x=3; Met la valeur 3 dans la variable x = d'affectation reste de la division Met la valeur 3.00 dans la variable x = Prog. Struct. - C 3. Les opérateurs 36
Les opérateurs d'assignations x=x+2; peut aussi s'écrire x+=2; += additionne deux valeurs et stocke le résultat dans la variable (à gauche) x -= soustrait deux valeurs et stocke le résultat dans la variable *= multiplie deux valeurs et stocke le résultat dans la variable /= divise deux valeurs et stocke le résultat dans la variable x=a=b=3; Prog. Struct. - C x= (a= (b=3)); 3. Les opérateurs 37
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 38
Les opérateurs de comparaison utilisés lors de tests Opérateur Exemple Résultat si x vaut 7 == égalité x==3 Retourne 1 si x est égal à 3, sinon 0 < infériorité stricte x<3 Retourne 1 si x est inférieur à 3, sinon 0 <= infériorité x<=3 Retourne 1 si x est inférieur ou égal à 3, sinon 0 > supériorité stricte x>3 Retourne 1 si x est supérieur à 3, sinon 0 >= supériorité x>=3 Retourne 1 si x est supérieur ou égal à 3, sinon 0!= différence x!=3 Retourne 1 si x est différent de 3, sinon 0 Prog. Struct. - C 3. Les opérateurs 39
Les opérateurs bit-à-bit Opérateur & ^ ET OU OU exclusif Prog. Struct. - C Syntaxe 9 & 12 Résultat 1001 & 1100 1000 8 9 12 1001 1100 1101 13 9 ^ 12 1001 ^ 1100 0101 5 3. Les opérateurs 40
Les opérateurs de décalage de bit Opérateur Syntaxe Résultat 6 << 1 << 00000110 << 1 = 00001100 Décalage à gauche 12 x2 6 >> 1 >> Décalage à droite avec conservation du signe 00000110 >> 1 = 00000011 3 /2 En signé : -6 <<1 = -12 Prog. Struct. - C -6 >>1 = -3 3. Les opérateurs 11111010 << 1 = 11110100 11111010 >> 1 = 11111101 41
Les priorités +++ () -* + << < == & ^ &&?: = [] ++! ~ / % >> <= >= >!= += -= etc. --Prog. Struct. - C 3. Les opérateurs 42
4 types d'instructions Nulle ; Expression a=b+1; Prédéfinie condition ou boucle if () Bloc { } Prog. Struct. - C 4. Les structures conditionnelles 43
Les structures conditionnelles Les instructions de branchement conditionnel if(condition) if(condition) else switch(variable) case si (vrai) alors sinon... Les instructions de boucle while(condition) do while(condition); for(initialisation;condition;incrementation) Prog. Struct. - C 4. Les structures conditionnelles 44
L'instruction if syntaxe : if(condition) { instructions; } FAUX condition VRAI instructions Prog. Struct. - C 4. Les structures conditionnelles 45
L'instruction if(condition) else syntaxe : if(condition) { instructions; } else { instructions; } Prog. Struct. - C condition VRAI FAUX instructions instructions 4. Les structures conditionnelles 46
L'instruction if else Exemple : if (var1==0) //si var1 vaut 0 { //alors on affiche printf("la variable est nulle\n"); } else //sinon c'est faux { if (var1 > 0) { printf("elle est positive\n"); else { printf("elle est négative"); } Prog. Struct. - C 4. Les instructions conditionnelles } } 47
Attention aux forêts d'if() exemple : if (var1!=0) if (var1 > 0) printf("elle est positive\n"); else printf("elle est négative\n"); else se rapporte toujours au if le plus proche Prog. Struct. - C 4. Les instructions conditionnelles 48
L'opérateur conditionnel (condition)? instruction_vrai : instruct_faux exemple : x = 3; y = 2; max_xy = ((x>=y)? x : y); = 1 Prog. Struct. - C max_xy = x; 4. Les instructions conditionnelles 49
Pour faire plusieurs tests à la fois : les opérateurs conditionnels logiques Opérateur &&! OU logique ET logique NON logique Prog. Struct. - C Syntaxe ((cond1) (cond2)) ((cond1)&&(cond2)) a b a b a&&b!a 0 0 0 0 1 0 1 1 0 1 1 0 1 0 0 1 1 1 1 0 (!condition) 3. Les opérateurs 50
L'instruction de choix multiples : switch Syntaxe : switch (expr) { case const1: instructions; break; case const2: instructions; break; default: instructions; break; } Prog. Struct. - C? ==const1 V instr. 4. Les instructions conditionnelles F F? ==const2 V instr.?!=const1,2 V instr. 51
exemple : switch char choix; printf("taper 1 ou 2"); scanf("%c",&choix); switch(choix) { case '1': printf("vous avez tape 1\n"); break; case '2': printf("vous avez tape 2\n"); break; default : printf("je vous ai dit 1 ou 2 pas %c\n",choix); break; } Prog. Struct. - C 4. Les instructions conditionnelles 52
Les instructions de boucle : pour répéter les mêmes instructions plusieurs fois Prog. Struct. - C 4. Les instructions conditionnelles 53
L'instruction while tant que (condition vraie) syntaxe : condition while(condition) { instructions; } Prog. Struct. - C FAUX VRAI instructions 4. Les instructions conditionnelles 54
L'instruction do while faire tant que (condition vraie) syntaxe : do { instructions instructions; }while(condition); Prog. Struct. - C VRAI condition 4. Les instructions conditionnelles FAUX 55
L'instruction for() initialisation du compteur de boucle syntaxe : for( init;condition;incrément) { instructions; condition } VRAI exemple : for(i=0;i<100;i++) { printf("%d\n",i); } Prog. Struct. - C FAUX instructions modification du compteur de boucle 4. Les instructions conditionnelles 56
Attention aux boucles sans fin ; exemple : F 1 for( ; ; ) { printf("sans fin\n"); } Prog. Struct. - C 4. Les instructions conditionnelles V Affichage "sans fin" ; 57
Les instructions de sortie : pourquoi sont-elles utiles? x=1 exemple : x=1; while(x<=10) { a=1/(x-7); printf("%f",a); x++; }? x <= 10 V a=1/(x-7) Que va-t-il se passer quand x=7? Prog. Struct. - C F affichage a 4. Les instructions conditionnelles x=x+1 58
Les instructions de sortie : continue x=1 exemple : x=1; while(x<=10) { if (x==7) { printf("division par 0"); x++; continue; } a=1/(x-7); printf("%f",a); x++; } Prog. Struct. - C? x <= 10 F V? x ==7 F V affiche /0 x=x+1 4. Les instructions conditionnelles a=1/(x-7) affichage de a x=x+1 59
Les instructions de sortie : break exemple : x=1; while(x<=10) { a = x-7; printf("%f", 1/a); x++; } Que va-t-il se passer quand x=7? Prog. Struct. - C 4. Les instructions conditionnelles x=1 F? x <=10 V a=x-7 affichage 1/a x=x+1 60
Les instructions de sortie : x=1 break exemple : x=1; while(x<=10) { a = x-7; if (a == 0) { printf("/ par 0"); break; } printf("%f", 1/a); x++; } Prog. Struct. - C? x <=10 F V a=x-7? a == 0 F V affiche /0 affichage 1/a x=x+1 4. Les instructions conditionnelles 61
Les instructions de sortie : return syntaxe : return(expression); exemple : int main() { return(0); } Prog. Struct. - C 4. Les instructions conditionnelles 62
Département Génie Civil & Département Mécanique Énergétique Exemples Résolution numérique d'une équation du second degré Programme mystère Affectation et récurrence
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é 64
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 si D est égal à 0 3 alors3 x1 -b/2a Afficher x1 sinon3 x1 (-b -sqrt(d))/2a x2 (-b+sqrt(d))/2a Afficher x1 et x2 Fin si3 Fin si2 Fin si1 Prog. Struct. C 5. Ex : équation du 2nd degré 65
Résolution de ax2+bx+c=0 : Organigramme Acquisition de a, b, c VRAI a= = 0 FAUX Calcul de D V Affichage C pas 2 degré D<0 F D==0 F V Pas de racines Racine double 2 Racines distinctes fin Prog. Struct. C 5. Ex : équation du 2nd degré 66
Le squelette #include <stdio.h> #include <math.h> Directives du pré processeur 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 } Prog. Struct. C 5. Ex : équation du 2nd degré 67
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é 68
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é 69
toujours dans la fonction main () /*Test du contenu de a*/ if (a == 0.0) { printf("\nce n'est pas une eq. du second degré"); } else { /*Ouverture du bloc d'instruction a!= de 0*/ /*Calcul de delta */ delta = b*b-4*a*c; /*Test sur delta*/ if (delta < 0) printf("\npas de racines"); else { /*ouverture du bloc d'instruction delta >=0*/ Prog. Struct. C 5. Ex : équation du 2nd degré 70
Fin du main () if (delta == 0) /*Test delta nul*/ { x1 = -b/(2*a); printf ("\nracine double :%f",x1); } else /*Bloc d'intruction delta positif*/ { x1=(-b-sqrt(delta))/a/2; x2=(-b+sqrt(delta))/a/2; printf("x1=%f x2=%f \n",x1,x2); }/*fin delta>0*/ }/*Fin delta <0*/ }/*Fin a!= 0*/ return 0; }/*Fin programme*/ secondeg.c Prog. Struct. C 5. Ex : équation du 2nd degré 71
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; } Prog. Struct. C printf("\nentrez la valeur de a :"); scanf("%f",&a); printf("\nentrez la valeur de b :"); scanf("%f",&b); r=0.0; while (b!=0.0) { if(((int)b)%2 ==0) { b=b/2; a=2*a; } else { b=b-1; r=r+a; } } printf("\n r = %f",r); return(0); 5. Ex : équation du 2nd degré 72
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é 73
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é 74
Exemple : Calculer Sn = ( 1) n i= 1 i+ 1 i Ce qui donne la relation de récurrence : Sk = Sk 1 + Avec S1 = 1 ( 1) k+ 1 k recurrence.c Prog. Struct. C 5. Ex : équation du 2nd degré 75
Département Génie Civil & Département Mécanique Énergétique Les pointeurs et les tableaux 1. Les pointeurs 2. Les tableaux Les chaînes de caractères Les tableaux à plusieurs indices Prog. struct. : C III-Les pointeurs et les tableaux 76
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... 77
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... 78
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... 79
Mémoire, adresse et pointeur http://www.siteduzero.com/ Prog. struct. : C III-Les pointeurs... 80
L adressage indirect int i,*padi; i=10; padi = Prog. struct. : C contenant 10 Adresse de i i &i; *padi = 12; contenu contenu padi contenant Adresse de i Adresse de padi III-Les pointeurs... 81
L adressage indirect *padi padi = &i; = 12; Prog. struct. : C contenant 12 Adresse de i i int i,*padi; i=10; contenu padi contenu contenant Adresse de i Adresse de padi III-Les pointeurs... 82
& 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... 83
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... 84
Exemple : contenant contenu int i = 80; double xx=3.1415; double *pad; pad = &xx; 80 3.1415 100? 60 64 80 3.1415 100 pad = pad+i; /*pad +i*sizeof(double) c.a.d. 64 + 80*8 octets*/ Prog. struct. : C 60 64 III-Les pointeurs... 64 60 64 80 3.1415 100 704 nom i xx pad i xx pad i xx pad 85
Les Tableaux 1. Les tableaux mono-dimensionnels 2. Les chaînes de caractères 3. Les tableaux de tableaux Prog. struct. : C III-... Les tableaux 86
Qu'est-ce qu'un tableau? C'est une suite de variables de même type, rangées dans un espace contigu de la mémoire. Prog. struct. : C III-... Les tableaux 87
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 88
Exemples double Toto [100]; //Toto est un tableau de 100 doubles int MyTab [5] = {1,4,8,7,6}; //MyTab est un tableau de 5 entiers initialisé à : //MyTab [0]= 1,, MyTab [4]= 6 #define NBELEM 512 float SonTab [NBELEM]; //SonTab est un tableau de NBELEM float Prog. struct. : C III-... Les tableaux 89
Tableaux à un seul indice et Pointeur int Tab[N]; Tab[0] Tab[1] Tab[2] Tab+i Tab[N-1] &Tab[i] tableau pointeur *(Tab+i) Tab [i] printf("%d",*tab); ou printf("%d",tab[0]); scanf("%d",tab+2); ou scanf("%d",&tab[2]); Prog. struct. : C III-... Les tableaux 90
Exemple : Saisir et afficher les éléments d'un tableau Mon premier tableau Prog. struct. : C III-... Les tableaux 91
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 92
Chaînes de caractères char *pfin; char cbonjour [] = "Bonjour"; printf("%s\n", cbonjour); pfin = cbonjour + 3; printf("%s\n", pfin); pfin = cbonjour+strlen(cbonjour); do { printf ("%c",*--pfin); }while (pfin!= cbonjour); Prog. struct. : C III-... Les tableaux 93
Pour comprendre 'B' cbonjour 'o' 'n' 'j' pfin 'o' 'r' Ø cbonjour+3 printf("%s\n", cbonjour); pfin = cbonjour + 3; printf("%s\n", pfin); Prog. struct. : C 'u' III-... Les tableaux Bonjour jour 94
Pour comprendre 'B' 'o' 'n' 'j' 'o' 'u' 'r' Ø pfin cbonjour strlen(cbonjour) renvoie 7 Adresse pointée par pfin Prog. struct. : C Adresse pointée par cbonjour+7 III-... Les tableaux 95
Chaîne de Caractères Exemple!OG Prog. struct. : C III-... Les tableaux 96
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 97
Tableau à deux indices Ligne0 Ligne1... NCol NCol NCol NLign x NCol Prog. Struct. - C III -... Les tableaux 98
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 III -... Les tableaux 99
Département Génie Civil & Département Mécanique Énergétique Les fonctions 1. 2. 3. 4. Prog. Struct. - C Introduction Mise en œuvre Passage par valeur et par adresse Pour aller plus loin IV - Les Fonctions 100
Jusqu'à maintenant, vos programmes ressemblent à ça... #include <stdio.h> #define N 10 int main() { int i; float TAB[N]; Directives au pré-processeur La fonction principale Il ne peut y en avoir qu'une!! printf("entrez les valeurs du tableau : "); for(i=0 ; i<n; i++) { scanf("%f",&tab[i]); } } printf("les valeurs du tableau sont :\n "); for(i=0 ; i<n; i++) { printf("%f",tab[i]); } return 0; Prog. Struct. - C IV - Les Fonctions 101
Introduction Une fonction vue par un débutant C'est un morceau de programme qui sert à faire quelque chose de précis. Entrée Fonction = brique Sortie Le but : simplifier le code source, pour ne pas avoir à réécrire le même code plusieurs fois. Prog. Struct. - C IV - Les Fonctions 102
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 103
Instruction i ; Appel MaFonction() ; Adresse Instruction i+2 ; MaFonction Ligne n 1 de MaFonction() La suite de MaFonction() Instruction return(); Prog. Struct. - C IV - Les Fonctions 104
Exemple avec la fonction sqrt() : Instruction i ; Adresse X = sqrt(4) ; Instruction i+2 ; 4 sqrt(argument) if (argument>0) Le calcul de sqrt(4) return(2) Prog. Struct. - C IV - Les Fonctions Retour de 2 105
Une fonction vue du programmeur c.a.d. vous Les fonctions facilitent l'organisation et la mise au point du programme puisqu'il est divisé en fonctions qui 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 bibliothèques de fonctions pour développement de son application. Prog. Struct. - C IV - Les Fonctions utilise des accélérer le 106
Instruction i; MaFonction(10,x+y,z); z Instruction_suiv; Passage de x+y paramètres 10 MaFonction { Instructions De MaFonction return; } Prog. Struct. - C IV - Les Fonctions 107
Fonction : Mise en œuvre #include <stdio.h> /* 2) Le prototypage */ int main() { /* 3) L'appel */ } /* 1) La définition */ Prog. Struct. - C IV - Les Fonctions 108
1) La Définition Localisation : #include <stdio.h> int main() { } //Définition des fonctions Exemples de fonctions : Arguments ou paramètres void AfficheTableau(float *ptab, int nlignes) { int i; for (i=0; i<nlignes ; i++) { printf("%f", *(ptab+i) ); } } double CalcDisc(double Arga,double Argb,double Argc) { return Argb*Argb-4*Arga*Argc; } Prog. Struct. - C IV - Les Fonctions 109
2) Le Prototypage Type_Ret Ident_fonc (,Type Argument, ); Exemples de prototypages : void AfficheTableau(float *ptab, int nlignes); double CalcDiscri (double Arga,double Argb,double Argc); Où ça se trouve dans le programme? #include <stdio.h> // c'est ICI pour le prototypage des fonctions!!! int main() { } Prog. Struct. - C IV - Les Fonctions 110
3) L'appel de la fonction Paramètres de la fonction { double ValDisc; ValDisc = CalcDisc (a,b,c); } 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 111
Ma première fonction \fonctions\exemple1.prj Prog. Struct. - C IV - Les Fonctions 112
2 types de fonctions 1) Celles qui ne retournent rien (void). Elles sont également 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 113
2 types de fonctions 2) Celles qui retournent quelque chose (elles renvoient une valeur). Pour cela, il faut utiliser l'instruction return : return expression; EXEMPLE : /* Une fonction calculant le produit de deux entiers */ /* 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 114
2 types d'arguments : 1) ceux passés par valeur On indique au compilateur que fonction1 est une fonction qui ne retourne rien et qui admet pour paramètre un double //Prototypage void fonction1(double z); //Définition void fonction1(double z) { z = z * 2.0; printf("z = %lf\n",z); } Lors de l'appel de la fonction, le contenu de la zone repérée par z sera x 2 Prog. Struct. - C 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é. IV - Les Fonctions 115
Exécution : Appel de la fonction /*A l'intérieur de la fonction appelante par exemple le main()*/ Zone de 8 octets réservée pour x 20.0 Zone de 8 octets réservée pour z 20.0 double x = 20.0;... fonction1 (x); pile Prog. Struct. - C IV - Les Fonctions 116
Lors de l exécution 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; } Zone de 8 octets réservée pour z 20.0 40.0 pile Prog. Struct. - C IV - Les Fonctions 117
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 118
2 types d'arguments : 2) ceux passés par adresse On indique au compilateur que : - fonction2 ne retourne rien, - et admet pour paramètre un pointeur sur double //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. Ce qui est pointé par pz sera x 2 lors de l'appel de la fonction. Prog. Struct. - C IV - Les Fonctions 119
Exécution : Appel de la fonction Zone de 8 octets réservée par x 20.0 //A l'intérieur de la fonction appelante double x = 20.0;... 4 octets réservés par pz fonction2 (&x); &x pile Prog. Struct. - C IV - Les Fonctions 120
Au sein de la fonction x inaccessible dans fonction2, mais atteint grâce à l'adressage indirect 20.0 40.0 void fonction2 (double *pz) { *pz =(*pz)*2.0; } 4 octets réservés pour pz &x pile Prog. Struct. - C IV - Les Fonctions 121
Après l exécution 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 pile 122
Ma deuxième fonction val_et_adr.prj Exemple Prog. Struct. - C IV - Les Fonctions 123
Rappels sur les fonctions 3 étapes pour la mise en œuvre : le prototypage, la 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 124
Squelette d'un programme Zone des directives de préprocesseur #include Que se cache-t-il dans stdio.h? #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 Prog. Struct. - C IV - Les Fonctions 125
! 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 126
Pour aller plus loin 1. 2. 3. 4. La récursivité La portée des variables : locales ou globales Les tableaux comme arguments Les pointeurs sur fonctions Prog. Struct. - C IV - Les Fonctions 127
1) La Récursivité : La fonction s'appelle elle-même! Exemple : double Factorielle (int n); double Factorielle (int n) { if (n <= 0) return 1; } //Prototype Condition d'arrêt return n*factorielle (n-1); Appel récursif factorielle.prj Prog. Struct. - C IV - Les Fonctions 128
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 129
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 130
3) Tableaux passés en paramètres à une fonction Tableaux à deux dimensions (2 indices) Type_ret Ident(Type_Tab Tab[][NCOL], int nlign, ); OU Type_ret Ident(Type_Tab (*ptab)[ncol], int nlign, ); ex : void affiche2d(float *ptab[10], int Nblig); Prog. Struct. - C IV - Les Fonctions 131
4) Les Pointeurs sur fonction Déclaration Affectation Utilisation Prog. Struct. - C IV - Les Fonctions 132
Déclaration d'un pointeur sur fonction Type_Val_Ret(*Ident_ptr_Fonc)(Signature_fonc); Liste ordonnée des types des arguments de la fonction sans les identificateurs des arguments Signature_fonc Exemple double (*pfonc)(double); Prog. Struct. - C pfonc est un pointeur sur une fonction retournant un double et admettant un double en argument. IV - Les Fonctions 133
Initialisation, Affectation d'un pointeur sur fonction double (*pfonc)(double); Nécessite #include <math.h> double (*ptabfonc [3])(double)={sin,cos,tan}; pfonc = MaFonc; Le prototype de MaFonc doit être connu par le compilateur. Prog. Struct. - C IV - Les Fonctions 134
Pointeurs sur fonction pointfonct.prj Prog. Struct. - C IV - Les Fonctions 135
Département Génie Civil & Département Mécanique Énergétique Les types utilisateurs 1. Les structures 2. Les unions 3. Les énumérations http://iusti.polytech.univ-mrs.fr/~bergougnoux/enseignement.htm Prog. struct. C
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 137
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 138
La fiche d'un élève Polytech Nom : PIGNON Prénom : François Adresse : 12 place du marché 13013 Marseille Département Polytech : MT Année : 3 Spécialité :aucune Login : PIGNMT12 Password : juste12 Email : Francois.Pignon@polytech.univ-mrs.fr Prog. struct. C V- Les structures 139
Traduction Informatique Formulaire Type de donnée Structure struct modèle Fiche Variable de type struct objet Fichier Tableau ou liste de Ensemble variables de type d'objets struct Prog. struct. C V- Les structures 140
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 141
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 142
Exemple 1 : Définition du type POLYTECH struct { char char char int int int char char char }; POLYTECH Nom[80]; Prenom[80]; Adresse[200]; Depart; Annee; Spec; Login[10]; Passw[8]; Email[30]; Prog. struct. C 9 champs avec des identificateurs pas contigus mais à la suite V- Les structures 143
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 144
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 145
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 146
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 147
Définition de type composé Structure nommée struct tcomplex { double Re; double Im; }; ce nouveau type suit le modèle struct tcomplex typedef struct tcomplex Complex; définition d'un nouveau type Prog. struct. C V- Les structures Le nom de ce nouveau type est Complex 148
Exemple 2 : Représentation des nombres complexes Complex zi = {0,1.0}; Complex *pz; Complex ztabval [10]; Déclarations des variables zi, pz et ztabval de type Complex pz = &zi; pz->re = sqrt(2)/2; pz->im = pz->re; ztabval[0].re = 11.5; Utilisation de ces variables (ztabval+5)->im = sqrt(2); Prog. struct. C V- Les structures 149
Union Ensemble de variables de type 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 unions 150
É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 énumérations 151
Exemple enum tdepart{gc,gii,me,mt}; typedef enum tdepart DEPART; POLYTECH *pelev; /*Mettre une adresse valide dans pelev*/ pelev->depart = MT; Prog. struct. C V- Les structures 152
Département Génie Civil & Département Mécanique Énergétique La gestion de fichiers 1. 2. 3. 4. Les Flots Ouverture / Fermeture d'un fichier Lecture / Écriture dans un fichier Formats
1 Fichier sur 1 Disque Chemin d'accès "path" : C:\Repertoire\SousRep1\...\SousRepN\Nom.ext Structure arborescente de répertoire, sous répertoires, Unité logique Nom du Fichier et son extension Le mode d'accès Les éventuels attributs de protection. Prog. struct. C VI- La gestion de fichiers 154
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 155
Flot d informations Source : Destination : Mémoire de masse Mémoire de masse Clavier Port Série Mémoire Flot Flot//stream stream octets Console Port Série Mémoire Carte SD Carte SD...... Prog. struct. C VI- La gestion de fichiers 156
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 157
<stdio.h> standard input output C'est là qu'est définie la structure FILE! Prog. struct. C VI- La gestion de fichiers 158
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 159
Les Modes d'ouverture Les flots/fichiers peuvent être ouverts en mode : Lecture "r" la destination existe "r+" possibilité d'écriture Ecriture "w" la destination est 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"). Prog. struct. C VI- La gestion de fichiers 160
Les Fonctions générales 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) Prog. struct. C VI- La gestion de fichiers 161
Exemple #include <stdio.h> int main() { //pointeurs sur fichier FILE *pfascii,*pfbin; pfascii = fopen("totoascii.txt","w"); pfbin = fopen("totobin.moi","wb"); fclose(pfascii); fclose(pfbin); } Prog. struct. C texte_bin.prj VI- La gestion de fichiers 162
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 163
Exemple #include <stdio.h> int main() { fprintf(stdout,"1ere alternative à printf()\n"); fputs("\n En voila une autre",stdout); } ecran.prj Prog. struct. C VI- La gestion de fichiers 164
É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 165
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 166
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îtreA la position dans le fichier : u tilis *flot, fpos_t *ptr) void fgetpos(file e r av ec p réca: Fixer la position dans le fichier utiofpos_t *ptr) void fsetpos(file *flot, const n!! /*Place dans ptr la position courante dans le fichier indiqué en vue de son utilisation par fsetpos*/ Prog. struct. C VI- La gestion de fichiers 167
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 168
Formats d'écriture %[flags][width][.precision][{h L l}]type flags (-,+,0,,#) : mise en forme du texte width : Longueur minimum du texte.precision : Nombre de chiffres 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 169
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 170
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 171
Exemple 1 : texte formaté -> fichier binaire... int main() { FILE *srce; /* fichier de texte */ FILE *dest; /* fichier binaire */... if ((srce = fopen(nomfich, "r")) == NULL) exit(erreur_ouverture);... for (;;) //tant qu'il y a des choses à lire { if ((nb=fscanf(srce, "%s %s\n", art.nom, art.prenom))!= 2) break;... }... } Prog. struct. C fichier.prj VI- La gestion de fichiers 172
Exemple 2 : les formats #include <stdio.h> int main() { const double pi=4*atan(1); printf("%lf\n",pi); printf("%1.3lf",pi); } formats.prj Prog. struct. C VI- La gestion de fichiers 173
Département Génie Civil & Département Mécanique Énergétique Programmation modulaire (multi-fichiers) 1. 2. 3. 4. Généralités Mise en œuvre Macros Variables de portée fichier
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 175
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 176
La mise en œuvre Programme monofichier En-tête Programme modulaire Fichiers.h Module Fonction main Fichier.c Sans fonction main() Définition de vos fonctions Prog. Struct. C Fichiers.c IX - Prog. Modulaire 177
Conséquences : Le fichier *.prj s'agrandit Prog. Struct. C IX - Prog. Modulaire 178
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 179
La directive #include Syntaxe : #include <stdio.h> #include "[nomchemin\ \]nomfichier.h" Action : Inclure Avant la compilation, le pré-processeur met en lieu et place de la directive le fichier.h Prog. Struct. C IX - Prog. Modulaire 180
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 181
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 182
#define pour la taille des tableaux #define NMAX 10... int main() { float vect[nmax]; Le programme est développé avec 10 pour remplacer NMAX. Après le programmeur pourra mettre 10000... for(i=0 ; i<nmax; i++) {... } } Prog. Struct. C IX - Prog. Modulaire 183
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 184
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 185
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 186
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 187
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 188
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 189
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 190
Exemple modulaire.prj Prog. Struct. C IX - Prog. Modulaire 191
Département Département Génie Génie Civil Civil & & Département Département Mécanique Mécanique Énergétique Énergétique Allocation Dynamique de Mémoire 1. Généralités 2. Les fonctions malloc() & Cie
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. 193
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. 194
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. 195
Configuration de la mémoire pendant l exécution Tas Programme Variables statiques Le tas (heap) est la mémoire inutilisée lors de l exécution du programme. Pile OS (windows par ex.) C'est là que va se faire l'allocation dynamique de mémoire. Prog. struct. C X - Alloc. dyn. mem. 196
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. 197
La fonction malloc() Prototype dans <stdlib.h> ou <malloc.h> : void * malloc (size_t nsize); Appel : typedef struct POLYTECH_EL ELP; ELP *ptabelev; int nnbel; ptabelev = (ELP*)malloc(nNbEl* sizeof(elp)); On type l'adresse Prog. struct. C Taille d'une variable de type ELP X - Alloc. dyn. mem. 198
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. 199
Allocation pour un tableau à 2 dimensions Exemple : double **MAT;... MAT = malloc(nl * sizeof(double *)); if (MAT == NULL) return 0; for (i = 0; i < nl; i++) { MAT[i] = malloc(nc * sizeof(double)); } Prog. struct. C X - Alloc. dyn. mem. 200
La fonction calloc() Prototype : void *calloc(size_t nelem,size_t Taille_Elem); Appel : ptabelev =(struct POLYTECH_EL*)calloc (nnbel, sizeof(struct POLYTECH_EL)); Mise à 0 des octets réservés. Si mémoire insuffisante réagit comme malloc() Prog. struct. C X - Alloc. dyn. mem. 201
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. 202
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. 203
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. 204
Exemple allocat.prj Prog. struct. C X - Alloc. dyn. mem. 205
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. 206
Listes chaînées vs Tableaux Une fois créé, on ne peut plus le modifier! 1 Tableau Prog. struct. C X - Alloc. dyn. mem. 207
Listes chaînées vs Tableaux 1 Liste Prog. struct. C Une fois créée, on peut la modifier! X - Alloc. dyn. mem. 208
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. 209
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. 210
Exemple de fonction pour l'initialisation : Liste *initialisation(void) { Liste *liste=malloc(sizeof(*liste)); Element *element=malloc(sizeof(*element)); } if (liste==null element==null) { exit(exit_failure); } element->nombre=0; element->suivant_sur_la_liste=null; liste->premier_sur_la_liste=element; Prog. struct. C X - Alloc. dyn. mem. 211
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 Bibliographie 212
Pour en savoir plus Cours de C sur le Web : http://www.commentcamarche.net Henri Garreta http://www.dil.univ-mrs.fr/~garreta http://c.developpez.com/cours http://www.siteduzero.com/tutoriel-3-14189-apprenez http://iusti.polytech.univ-mrs.fr/~bergougnoux/enseignement.htm IDE en open source Dev-C++ À télécharger à partir de http://www.commentcamarche.net Progr. struct. - C Sources 213