Cours de c

1 333 vues

Publié le

ùù

Publié dans : Périphériques & matériel
0 commentaire
1 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

Aucun téléchargement
Vues
Nombre de vues
1 333
Sur SlideShare
0
Issues des intégrations
0
Intégrations
5
Actions
Partages
0
Téléchargements
67
Commentaires
0
J’aime
1
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Cours de c

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

×