1 Rappel et compléments de la programmation en langage C.

Présentation au sujet: "1 Rappel et compléments de la programmation en langage C."— Transcription de la présentation:

1 1 Rappel et compléments de la programmation en langage C

2 2 Déclarer une fonction intprint_table(double start, double end, double step) { doubled; intlines = 1; printf("Celsius\tFarenheit\n"); for(d = start; d <= end; d += step, lines++) printf("%.1lf\t%.1lf\n", d, d * 1.8 + 32); return lines; } 3 doubles comme paramètresTYPE de la valeur de retour Valeur renvoyée Nom de la fonction

3 3 Appeler une fonction #include intprint_table(double, double, double); void main(void) { intcombien; doubleend = 100.0; combien = print_table(1.0,end,3); print_table(end, 200, 15); } IMPORTANT: cette instruction spécifie comment la fonction est définie Le compilateur attend des doubles; les conversions sont automatiques Ici, on ne tient pas compte de la valeur de retour

4 4 void main(void) { int Val ; Val = addition(); printf(“val = %d”, Val); } int addition() { float tmp; tmp = calcule(2.5,3) + calcule(5,7.2); return (int)tmp; } float calcule(float float1, float float2) { return ( (float1 + float2 ) / 2) ; } float calculeFloat(float, float); int addition();

5 5 Règles de visibilité des variables Le C est un language structuré en blocs { }, les variables ne peuvent être utilisées que là où elles sont déclarées voidfunc(int x); int glo=0; // variable globale voidmain(void) { inti = 5, j, k = 2; //lacales à main floatf = 2.8, g; d = 3.7; func (i); } voidfunc(int v) { double d, e = 0.0, f =v; //lacales à func i++; g--;glo++; f = 0.0; } C’est le f local qui est utilisé Le compilateur ne connaît pas d Le compilateur ne connaît pas i et g

6 6 Identification des tableaux et pointeurs En C, le nom d’un tableau représente l’adresse de sa composante 0, donc a == &a[0] C'est pour cela que les tableaux passés comme paramètres dans une fonction sont modifiables Passer des tableaux aux fonctions Pour le compilateur, un tableau comme argument de fonction, c’est un pointeur vers sa composante 0 (à la réservation mémoire près). La fonction peut donc modifier n’importe quel élément (passage par référence) Le paramètre peut soit être déclaré comme tableau, soit comme pointeur int add_elements(int a[], int size) { int add_elements(int *p, int size) {

7 7 Exemple #include voidsum(long [], int); intmain(void) { longTab[6] = { 1, 2, 3, 5, 7, 11 }; sum(Tab, 6); printf("%ld\n", Tab[0]); return 0; } voidsum(long a[], int sz) { inti; longtotal = 0; for(i = 0; i < sz; i++) total += a[i]; a[0] = total; } 1 2 3 5 7 11 Tab a sz 6 29 2 3 5 7 11 Tab

8 8 Utiliser des pointeurs - exemple p end 1024 1000 #include longsum(long*, int); intmain(void) { longTab[6] = { 1, 2, 3, 5, 7, 11 }; printf("%ld\n", sum(Tab, 6)); return 0; } longsum(long *p, int sz) { long*end = p + sz; longtotal = 0; while(p < end) total += *p++; return total; } 1 2 3 5 7 11 Tab 1004 1000 1008 1012 1016 1020 1024 1 2 3 5 7 11 Tab

9 9 Quelle notation? A[0] est équivalent à *A A[i] est équivalent à *(A + i) &A[0] est équivalent à A shorta[8] = { 10, 20, 30, 40, 50, 60, 70, 80 }; short*p = a; printf("%d\n", a[3]); printf("%d\n", *(a + 3)); printf("%d\n", *(p + 3)); printf("%d\n", p[3]); shorta[8] = { 10, 20, 30, 40, 50, 60, 70, 80 }; short*p = a; printf("%d\n", a[3]); printf("%d\n", *(a + 3)); printf("%d\n", *(p + 3)); printf("%d\n", p[3]); a p 1020304050607080 1000100410081012 1002100610101014 1000 40

10 10 Passer des structures comme paramètres de fonction Une structure peut être passée, comme une autre variable, par valeur ou par adresse Passer par valeur n’est pas toujours efficace (recopiage à l’entrée) Passer par adresse ne nécessite pas de recopiage void Par_valeur(struct Membre m); void Par_reference(struct Membre *m); Par_valeur(m); Par_reference(&m); void Par_valeur(struct Membre m); void Par_reference(struct Membre *m); Par_valeur(m); Par_reference(&m);

11 11 Utiliser p->name L’écriture p->name est synonyme de (*p)->name, où p est un pointeur vers une structure voidaffiche_membre (struct Membre *p) { printf("nom = %s\n", p->nom); printf("adresse = %s\n", p->adresse); printf(”numéro de membre = %d\n", p->numero); printf("\nDate d’affiliation %d/%d/%d\n", p->creation.jour, p->creation.mois, p->creation.an); } voidaffiche_membre (struct Membre *p) { printf("nom = %s\n", p->nom); printf("adresse = %s\n", p->adresse); printf(”numéro de membre = %d\n", p->numero); printf("\nDate d’affiliation %d/%d/%d\n", p->creation.jour, p->creation.mois, p->creation.an); } Quand la structure est un pointeur ! !

12 12 Retour de structures dans une fonction Par valeur (recopiage) ou par référence struct Complex add(struct Complex a, struct Complex b) { struct Complex result = a; result.real_part += b.real_part; result.imag_part += b.imag_part; return result; } struct Complex add(struct Complex a, struct Complex b) { struct Complex result = a; result.real_part += b.real_part; result.imag_part += b.imag_part; return result; } struct Complexc1 = { 1.0, 1.1 }; struct Complexc2 = { 2.0, 2.1 }; struct Complexc3; c3 = add(c1, c2);/* c3 = c1 + c2 */ struct Complexc1 = { 1.0, 1.1 }; struct Complexc2 = { 2.0, 2.1 }; struct Complexc3; c3 = add(c1, c2);/* c3 = c1 + c2 */

13 13 Gestion des fichiers en C Elle est assurée par la librairie standard via un ensemble de fonctions commençant par “f” Avant de manipuler un fichier, il faut lui associer un descripteur (pointeur vers la structure fichier) Il y a 3 descripteurs automatiquement ouvert par tout programme C, stdin, stdout et stderr stdin (standard input) est connecté au clavier. On peut y lire stdout (standard output) et stderr (standard error) sont reliés au moniteur. On peut y écrire. FILE *f; /*déclare un descripteur f de fichier*/ !

14 14 Ouvrir et fermer des fichiers Les fichiers sont ouverts avec la fonction fopen ils sont fermés avec la fonction fclose FILE* fopen(const char* name, const char* mode); int fclose (FILE *f); FILE* fopen(const char* name, const char* mode); int fclose (FILE *f); mode (pour les fichiers TEXTES) :  « r » lecture seule  « w » écriture seule (destruction de l'ancienne version si elle existe)  « w+ » lecture/écriture (destruction ancienne version si elle existe)  « r+ » lecture/écriture d'un fichier existant (mise à jour), pas de création d'une nouvelle version.  « a+ » lecture/écriture d'un fichier existant (mise à jour), pas de création d'une nouvelle version, le pointeur est positionné à la fin du fichier. mode (pour les fichiers TEXTES) :  « r » lecture seule  « w » écriture seule (destruction de l'ancienne version si elle existe)  « w+ » lecture/écriture (destruction ancienne version si elle existe)  « r+ » lecture/écriture d'un fichier existant (mise à jour), pas de création d'une nouvelle version.  « a+ » lecture/écriture d'un fichier existant (mise à jour), pas de création d'une nouvelle version, le pointeur est positionné à la fin du fichier.

15 15 Ouvrir et fermer des fichiers Les fichiers sont ouverts avec la fonction fopen ils sont fermés avec la fonction fclose FILE* fopen(const char* name, const char* mode); int fclose (FILE *f); FILE* fopen(const char* name, const char* mode); int fclose (FILE *f); #include void main(void) { FILE*in; FILE*out; FILE*append; in = fopen("autoexec.bat", "r"); out = fopen("autoexec.bak", "w"); append = fopen("config.sys", "a"); /* … */ fclose(in); fclose(out); fclose(append); } #include void main(void) { FILE*in; FILE*out; FILE*append; in = fopen("autoexec.bat", "r"); out = fopen("autoexec.bak", "w"); append = fopen("config.sys", "a"); /* … */ fclose(in); fclose(out); fclose(append); }

16 16 Lecture et écriture sur fichier Fonctions de lecture intfscanf(FILE* stream, const char* format,...); intfgetc(FILE* stream); char*fgets(char* buffer, int size, FILE* stream); intfscanf(FILE* stream, const char* format,...); intfgetc(FILE* stream); char*fgets(char* buffer, int size, FILE* stream); Fonctions d’écriture int feof(FILE *f); /*renvoie une valeur non nulle si fin de fichier*/ intfprintf(FILE* stream, const char* format,...); intfputc(int ch, FILE* stream); intfputs(const char* buffer, FILE* stream); intfprintf(FILE* stream, const char* format,...); intfputc(int ch, FILE* stream); intfputs(const char* buffer, FILE* stream);

17 17 Exemple d’écriture (lecture) de fichier #include void sauvegarde( char titre[], int n, float x[], int ind [] ) { int i=0; FILE *f; f = fopen(“monfichier.dat”,”w”); if (f !=NULL){ fprintf(f,”%s\n”,titre); for (i=0; i < n; i++ ) { fprintf(f,”%f %d\n”, x[i],ind[i]); } fclose(f); } Mon titre 3.0 1 4.5 2 7.3 3 #include void main(void) { char titre[81]; float x[10]; int ind[10], i=0; FILE *f; f = fopen(“monfichier.dat”,”r”); if (f!= NULL) { fgets(titre,80,f); while(!feof(f)) { fscanf(f,”%f %d”,&x[i],&ind[i]); i++; } fclose(f); } La constante NULL (définie comme 0 dans stdio.h) réfère à une adresse non définie

18 Rappelle 18 mode lectur e écritur e crée le fichier vide le fichier position du flux rX début r+XX début w XXX w+XXXXdébut a XX fin a+XXX fin

19 Fichiers binaires Les fichiers binaires permettent des entrées/sorties de données au format interne de la machine. Les accès sont considérablement plus efficaces que pour des entrées/sorties formatées 19

20 Ouverture L’ouverture d’un fichier binaire se fait en ajoutant le spécificateur b au mode d’ouverture de l’appel fopen, toutes les autres options restant utilisables. FILE *fi, *fo; fi = fopen("data.bin", "r+b"); fo = fopen("result.bin", "wb"); 20

21 Entrees/sorties Les accès se font via deux fonctions, fread et fwrite, avec une interface banalisée : adresse de donnée, taille de la donnée, nombre de données (dans le cas d’utilisation de tableaux) et, bien sûr, le pointeur fichier. Pour les tailles des données à lire ou écrire, il est conseillé d’utiliser systématiquement l’opérateur sizeof. Exemple: double x, y; float tab[50]; /* Lecture sur ’fi’ de 2 scalaires */ fread(&x, sizeof(double), 1, fi); fread(&y, sizeof(double), 1, fi); /* Ecriture sur ’fo’ d’un tableau */ fwrite(tab, sizeof(float), 50, fo); 21

22 Remarque Ces fonctions retournent le nombre de données lues ou écrites, qui doit être égal au troisième argument de l’appel sauf problème. certaines des fonctions de lecture texte sont utilisables sur un fichier ouvert en mode binaire. En particulier les fonctions fgetc et fputc permettent une lecture ou écriture binaire, octet par octet. 22