MODULE 9
---------------------------- --------------------- #include //pour le système () {... #include codes C ++ ...} --------- ---------------------------------------- devrait être remplacé par: ----- -------------------------------------------- #include //utilisation C ++ wrapper pour appeler des fonctions C à partir des programmes de C ... #include using namespace std; ... {Codes C ++ ...} ---------------------------------------- --------- Dans VC ++ /VC ++ .NET l'iostream.h (tête avec .h) ne sera plus valable.
Il devrait être C de la tête, de sorte qu'il se conforme à la norme. En plus âgé compilateur C ++ Borland, ça fonctionne toujours, mais pas bon, pas plus ... et pour la norme C /C ++ de la portabilité devrait poser aucun problème ou mieux vous lire Module23 au https://www.tenouk.com/Module23.html pour obtenir la grande image ...
Pour les codes, ils ont encore des codes C C: o) ================================= ======================================== ========== ================================================== ============= //Ouverture et fermeture du fichier exemple #include #include //SUCCÈS = 0, FAIL = 1 en utilisant l'énumération enum {success, fail}; main (void) {FILE * fptr int; //le nom du fichier est tkk1103.txt et situé //dans le même dossier que ce programme omble filename [] = "tkk1103.txt"; //définir la valeur Reval Reval = SUCCÈS 0 int; //fichier d'ouverture de test pour la lecture, si sûr ...
si ((fptr = fopen (nom de fichier, "r")) == NULL) {printf (, nom de fichier "Impossible d'ouvrir% s. \\ n"); Reval = FAIL; //réinitialiser reval à 1} //si ne succès ... else {printf ("ouverture du dossier de l'% succès \\ n", nom de fichier); //le programme affichera l'adresse où //points fichier pointeur à .. printf ("La valeur de fptr: 0x% p \\ n", fptr); printf ("\\ n .... traitement de fichier doit être fait ici .... \\ n"); printf ("\\ nReady pour fermer le dossier de l'%. \\ n", nom de fichier); //fermer le flux de fichiers ...
si (fclose (fptr) == 0) printf ("Fermeture du dossier de l'% succès \\ n", nom de fichier); } //Pour Borland ... peut enlever la pause suivante et la bibliothèque, //stdlib.h pour le système d'autres compilateurs ("pause"); retourner reval; } ------------------------------ Testtwo.txt ---------------- ---------------------------------- OUVERTURE, lecture, écriture et la fermeture du fichier -------- ----------------------------------- fichier de test. Ce fichier nommé testtwo.txt. Après l'ouverture de fichiers pour la lecture et l'écriture, sans erreur, le contenu de ce fichier (testtwo.
txt) sera lu et sortie (écriture) à l'autre fichier nommé testone.txt et la sortie standard (écran /console) caractère par caractère !!! --- HEUREUX D'APPRENTISSAGE FOLKS !!! ---- ------------------------------------- -------------------------------------------------- ----- //Lecture et écriture un caractère à la fois #include #include //type de données énuméré, SUCCESS = 0, FAIL = 1 ENUM {success, fail}; //fonction prototype pour la lecture et l'écriture ... CharReadWrite void (FILE * aileron, FILE * fout); int main () {//déclarer deux pointeurs de fichiers ...
FILE * fptr1, * fptr2; //définir le nom de deux fichiers ... omble filename1 [] = "testone.txt"; carboniser filename2 [] = "testtwo.txt"; int reval = SUCCÈS; //tester la filename1 d'ouverture pour écrire .... //si échoue .... si ((fptr1 = fopen (filename1, "w")) == NULL) {printf ("Problème, ne peut ouvrir% s. \\ n ", filename1); Reval = FAIL; } //Si l'ouverture filename1 pour l'écriture est réussie, //test pour l'ouverture pour la lecture filename2, si échoue ... else if ((fptr2 = fopen (filename2, "r")) == NULL) {printf ("Problème, ne peut ouvrir% s \\ n ", filename2).
; Reval = FAIL; } //Si ouverture réussie pour lire filename2 //et écrit à NomFichier1 ... else {//appel de fonction pour la lecture et l'écriture ... CharReadWrite (fptr2, fptr1); //fermer les deux fichiers ... si (fclose (fptr1) == 0) printf ("% s \\ étroite avec succès n", filename1); si (fclose (fptr2) == 0) printf ("% s \\ étroite avec succès n", filename2); } //Pour Borland si compilé à l'aide de son système ... IDE («pause»); retourner reval; } //Lire écrire définition de fonction CharReadWrite void (FILE * aileron, FILE * fout) {int c; //si la fin du fichier est atteinte, do ...
while ((c = fgetc (fin)) = EOF!) {//écriture d'un fichier ... fputc (c, fout); //affichage sur l'écran ... putchar (c); } Printf ("\\ n"); } ------------------------------------ ---------- Testfour.txt --------------------------- ouverture, la lecture, l'écriture d'une ligne de caractères -------------- -------------------------------------- Ce fichier est testfour.txt. Le contenu de ce fichier sera lu ligne par ligne de caractères jusqu'à pas plus la ligne de caractère trouvé. Ensuite, ce sera la sortie à l'écran et sera également copié de déposer testhree.txt.
Vérifiez le contenu du fichier testhree.txt ... --------------------------------------- ------------- ------------------BONNE JOURNÉE--------------- ---- ---------------------------------------------- --------------------------------------- //Lecture et écriture d'une ligne à la fois # inclure énumération #include {success, fail, MAX_LEN = 100}; //prototype de fonction pour la lecture et écrit par la ligne ... LineReadWrite void (FILE * aileron, FILE fout *); int main (void) {FILE * fptr1, * fptr2; //fichier testhree.
txt se trouve à la racine, c: //vous pouvez mettre ce fichier à tout emplacement prévu //vous fournissez le chemin complet, même pour testfour.txt omble filename1 [] = "c: \\\\ testhree. SMS"; omble filename2 [] = "c: \\\\ testfour.txt"; omble reval = SUCCÈS; //test ouverture testhree.txt fichier en écriture, si sûr ... si ((fptr1 = fopen (filename1, "w")) == NULL) {printf ("Problème, ne peut pas ouvrir% s en écriture. \\ n" , filename1); Reval = FAIL; \\} //Ouverture testfour.txt fichier en lecture, si sûr ...
else if ((fptr2 = fopen (filename2, "r")) == NULL) {printf ("Problème, ne peut pas ouvrir% s en lecture test. n ", filename2); Reval = FAIL; } //Si l'ouverture de l'écriture et de la lecture vient de succès, faire ... else {//appel de fonction pour lire et écrire, ligne par ligne ... LineReadWrite (fptr2, fptr1); //Fermeture de deux fichiers stream ... si (fclose (fptr1) == 0) printf ("fermé avec succès \\ n% s.", filename1); si (fclose (fptr2) == 0) printf ("fermé avec succès \\ n% s.
", filename2); } //Pour Borland système de capture d'écran ("pause"); retourner reval; } //Définition de la fonction de la ligne de lecture, écriture ... LineReadWrite void (FILE * de nageoire, FILE * fout) {//variable locale ... omble buff [MAX_LEN]; while (! fgets (buff, MAX_LEN, FIN) = NULL) {//écrire dans le fichier ... fputs (chamois, fout); //écriture à l'écran ... printf ("% s", chamois); }} ----------------------------------------- ---- Testsix.
txt ------------------------------------------ OUVERTURE, lecture et l'écriture d'un bloc de Ceci est DATA ----------------------------------------------- déposer testsix.txt. Son contenu sera lu puis sortie à l'écran /console et copié testfive.txt fichier. La lecture et l'écriture reposent sur bloc de données. Peut-être cette méthode est plus rapide comparé à lecture /écriture par caractère, par la ligne .....
----------------------------- ------------------ ------------------FIN------------- ------------- ------------------------------------- -------------------------------------------------- ----------- //Lecture et écriture d'un bloc à un #include #include de temps //déclarer énumération type de données, vous apprendrez dans cette //autre module ... énumération {success, fail, MAX_LEN = 80}; //prototype de fonction pour le bloc lecture et d'écriture vide BlockReadWrite (FILE * aileron, FILE fout *); //prototype de fonction pour les messages d'erreur ...
int ErrorMsg (char * str); int main (void) {FILE * fptr1, * fptr2; //définir les noms de fichiers ... //l'emplacement des fichiers est au c: \\ Temp omble filename1 [] = "c: \\\\ temp \\\\ testfive.txt"; omble filename2 [] = "c: \\\\ temp \\\\ testsix.txt"; int reval = SUCCÈS; //ouverture testfive.txt fichier en écriture, si sûr ... si ((fptr1 = fopen (filename1, "w")) == NULL) {reval = ErrorMsg (filename1) test; } //Ouverture testsix.txt fichier en lecture, si sûr ...
else if ((fptr2 = fopen (filename2, "r")) == NULL) {reval = ErrorMsg (filename2) test; } //Si l'ouverture de fichiers pour écriture et la lecture est réussie, faire ... else {//fonction d'appel pour la lecture et l'écriture BlockReadWrite (fptr2, fptr1); //fermer les deux flux de fichiers ... si (fclose (fptr1) == 0) printf ("\\ succès fermée n s%", filename1); si (fclose (fptr2) == 0) printf ("\\ succès fermée n s%", filename2); } Printf ("\\ n"); //pour Borland ...
system ("pause"); retourner reval; } //Définition de fonction pour le bloc de lecture, écriture vide BlockReadWrite (FILE * aileron, FILE * fout) {int num; omble buff [MAX_LEN + 1]; //sans fin de fichier pour le fichier d'entrée, do ... while {//lecture ... num = fread (buff, sizeof (char), MAX_LEN, fin) (feof (FIN)!); //ajoute un mordu de caractère nul [num * sizeof (char)] = '\\ 0'; printf ("% s", chamois); //écriture ... fwrite (buff, sizeof (char), num, fout); }} //Définition de fonction pour message d'erreur int ErrorMsg (char * str) {//affiche le message d'erreur ...
printf ("Problème, ne peut ouvrir% s. \\ N", str); retourner FAIL; } -----------------------------------------tesseven.txt------------------------------------------------------ Ceci est la première ligne de texte, tesseven.txt fichier Ceci est le deuxième ligne de texte, tesseven.txt fichier Ceci est le troisième ligne de texte, tesseven.txt fichier Ceci est le quatrième ligne de texte, tesseven.
txt fichier - -------------------------------------------------- -------------------------------------------- //accès aléatoire à un déposer #include #include énumération {success, fail, MAX_LEN = 120}; //prototypes de fonctions, cherchent l'indicateur de position de fichier vide PtrSeek (fichier * fptr); //prototype de fonction, dit l'indicateur de position du fichier ... à long PtrTell (FILE * fptr); //prototype de fonction lu et écrit ... annuler DataRead (FILE * fptr); int ErrorMsg (char * str); main (void) {FILE * fptr int; omble filename [] = "c: \\\\ temp \\\\ tesseven.
txt"; int reval = SUCCÈS; //si il ya une ouverture de fichier pour la lecture erreur ... if ((fptr = fopen (nom de fichier, "r")) == NULL) {reval = ErrorMsg (nom de fichier); } //Si l'ouverture est réussie ... else {//PtrSeek () appel de fonction ... PtrSeek (fptr); //fermer le flux de fichiers ... si (fclose (fptr) == 0) printf ("% s correctement fermée. \\ n", nom de fichier); } //Pour Borland ...
system ("pause"); retourner reval; } //PtrSeek () définition de la fonction vide PtrSeek (FILE * fptr) {offset1 longue, offset2, offset3, offset4; offset1 = PtrTell (fptr); DataRead (fptr); offset2 = PtrTell (fptr); DataRead (fptr); offset3 = PtrTell (fptr); DataRead (fptr); offset4 = PtrTell (fptr); DataRead (fptr); printf ("\\ nReread l'tesseven.txt, dans un ordre aléatoire: \\ n"); //relire la 2e ligne de la fseek de tesseven.txt (fptr, offset2, SEEK_SET); DataRead (fptr); //relire la 1ère ligne de la fseek de tesseven.
txt (fptr, offset1, SEEK_SET); DataRead (fptr); //relire la 4e ligne de la fseek de tesseven.txt (fptr, offset4, SEEK_SET); DataRead (fptr); //relire la 3ème ligne de l'fseek de tesseven.txt (fptr, offset3, SEEK_SET); DataRead (fptr); } //PtrTell () définition de fonction à long PtrTell (FILE * fptr) {long reval; //indiquer la position de fptr ... Reval = ftell (fptr); printf ("Le fptr est à% ld \\ n", Reval); retourner reval; } //DataRead () définition de la fonction vide DataRead (FILE * fptr) {char buff [MAX_LEN]; //lecture de ligne de texte à la position de fptr ...
fgets (buff, MAX_LEN, fptr); //et afficher le texte ... printf ("->% s \\ n", chamois); } //Erreur définition de la fonction de message int ErrorMsg (char * str) {//affiche ce message d'erreur ... printf ("Problème, ne peut ouvrir% s. \\ N", str); retourner FAIL; } ------------------------------------------------- ------------------------------------------- //lecture, l'écriture, rembobinage et les données binaires #include #include énumération {success, fail, MAX_NUM = 5}; //fonctions prototypes ...
Datawrite void (FILE * fout); annuler DataRead (FILE * FIN); int ErrorMsg (char * str); main (void) {FILE * fptr int; //fichiers de type binaire ... omble filename [] = "c: \\\\ temp \\\\ teseight.bin"; int reval = SUCCÈS; //test pour la création, l'ouverture du fichier binaire pour l'écriture ... if ((fptr = fopen (nom de fichier, "WB +")) == NULL) {reval = ErrorMsg (nom de fichier); } Else {//Ecrire les données dans le fichier teseight.bin Datawrite (fptr); //réinitialiser l'indicateur de position du fichier ... rewind (fptr); //lire les données ...
DataRead (fptr); //fermer le flux de fichiers ... si (fclose (fptr) == 0) printf ("succès fermé \\ n% s", nom de fichier); } //Pour le système Borland ("pause"); retourner reval; } //Datawrite () définition de la fonction vide Datawrite (fichier * fout) {int i; à double buff [MAX_NUM] = {145,23, 589,69, 122,12, 253,21, 987,234}; printf ("La taille de buff:% d octets \\ n", sizeof (buff)); for (i = 0; i {printf ("% 5.
2f \\ n", chamois [i]); fwrite (& buff [i], sizeof (double), 1, fout);}} //DataRead () définition de fonction annuler DataRead (FILE * FIN) {int i; doubles x; printf ("\\ nReread du fichier binaire: \\ n"); for (i = 0; i {fread (& x, sizeof (double), (size_t) 1 , FIN); printf ("% 5.2f \\ n", x);}} //ErrorMsg () définition de la fonction int ErrorMsg (char * str) {printf ("Impossible d'ouvrir% s. \\ n", str); retour FAIL;} --------------------------------------- testcal.
txt ----- ---------------------------------- 23 12 33 10 4 6 44 31 7 50 ------ -------------------------------------------------- --------------------------------- /* Programme C pour calculer la moyenne d'une liste de numéros. * //* calculer le total d'un fichier, la sortie de la moyenne * //* dans un autre fichier * /#include /* pour la sortie () * /#include int main (void) {valeur int, totale = 0, count = 0; /* fileptrIn et fileptrOut sont des variables de type (FILE *) * /FILE * fileptrIn, * fileptrOut; omble filenameIn [100], filenameOut [100]; printf ("S'il vous plaît entrer un nom de fichier d'entrée (chemin de l'utilisation si nécessaire): \\ n" ); scanf ("% s", filenameIn); printf ("S'il vous plaît entrer un nom de fichier de sortie (chemin de l'utilisation si nécessaire): \\ n"); scanf ("% s", filenameOut); /* les fichiers ouverts pour la lecture, "r" et de l'écriture, "w" * /if ((fileptrIn = fopen (filenameIn, "r")) == NULL) {printf ("Erreur d'ouverture% s en lecture.
\\ n" , filenameIn); sortie
(1); } Else printf ("Ouverture% s en lecture est OK. \\ N", filenameIn); if ((fileptrOut = fopen (filenameOut, "w")) == NULL) {printf ("Erreur d'ouverture% s en écriture. \\ n", filenameOut); sortie
(1); } Else printf ("Ouverture% s en écriture est OK. \\ N", filenameOut); /* fscanf * /printf ("\\ nCalculate total ... \\ n"); while (EOF = fscanf (fileptrIn, «% i», et la valeur)!) {totale + = valeur; ++ compter; } /* fin de boucle while * //* Écrivez la valeur moyenne dans le fichier * //* fprintf * /printf ("Calculer la moyenne ... \\ n \\ n").
; fprintf (fileptrOut, "Moyenne de% i numéros =% f \\ n", compter, /(double) nombre total); printf ("% moyen des numéros i =% f \\ n \\ n", compte, total /(double) comptage); printf ("Vérifiez également le contenu du fichier \\ n de votre%", filenameOut); si (fclose (fileptrIn) == 0) printf ("% s \\ clôture de succès n", filenameIn); si (fclose (fileptrOut) == 0) printf ("% s \\ clôture de succès n", filenameOut); return 0; } ------------------------------------------------- -------------------------------------------- //Redirection un flux norme #include #include énumération {success, fail, STR_NUM = 6}; vide StrPrint (char ** str); int ErrorMsg (char * str); int main (void) {//déclarer et de définir un pointeur vers la chaîne .
.. char * str [STR_NUM] = {"Redirection un flux standard pour le fichier texte.", "Ces 5 lignes de texte seront redirigés", " tant de choses que vous pouvez faire si vous comprenez la "," concept, idée fondamentale - essayez celui-ci "," -------------- FAIT ---------- ---------------- "}; omble filename [] = "c: \\\\ temp \\\\ testnine.txt"; int reval = SUCCÈS; StrPrint (str); //créer le fichier si ne pas exister et ouvert pour l'écriture ... //si elles existent, jeter le contenu précédent ...
si (fReopen (nom de fichier, "w", stdout) == NULL) {reval = ErrorMsg (nom de fichier); } Else {//appel de fonction StrPrint () ... StrPrint (str); //Fermeture de la sortie standard ... fclose (stdout); } Return reval; } //StrPrint () définition de la fonction vide StrPrint (char ** str) {int i; for (i = 0; i //à la norme sortie écran /console ... printf ("% s \\ n", str [i]), le système ("pause");} //ErrorMsg () fonction définition int ErrorMsg (char * str) {printf ("Problème, ne peut pas ouvrir% s.
\\ n", str); retourner FAIL;} ---------------------- -------------------------------------------------- -------------- //Démontrer la #include remove () fonction #include void main () {//déclarer un tableau pour stocker nom de fichier ... omble filename [80]; printf ("Entrez le nom de fichier à supprimer:"); gets (nom de fichier); //vérifier toute erreur ... if (Supprimer (nom de fichier) == 0) printf (". Fichier% s a été supprimé \\ n", nom de fichier ); d'autre fprintf (stderr, "Erreur de suppression de fichier% s \\ n".
, nom de fichier), le système ("pause");} --------------------- -------------------------------------------------- ---------------- //Utilisation de renommer () pour modifier un nom de fichier #include #include void main () {char oldname [80], newname [80]; printf ("Entrez nom de fichier courant: "); obtient (oldname); printf (" Entrez le nouveau nom pour le fichier: "); gets (newname); if (renommer (oldname, newname) == 0) {printf ("% s a été renommer% s \\ n ", oldname, newname).; } Else {fprintf (stderr, ".
Une erreur est survenue renommer% s \\ n", oldname); } Système («pause»); } ------------------------------------------------- ------------------------------------------- //Copie d'un fichier #include #include int file_copy (char * oldname, char newname *); void main () {source de char [80], la destination [80]; //obtenir les noms de source et de destination printf ("fichier source \\ nEntrez:"); gets (source); printf ("fichier de destination \\ nEntrez:"); gets (destination); si (file_copy (source, destination) == 0) puts ("opération de copie réussie"); fprintf autre (stderr, "Erreur lors de l'opération de copie"); système («pause»); } Int file_copy (char * oldname, char * newname) {FILE * pli, * fnew; int c; //Ouvrir le fichier source pour la lecture en mode binaire si ((fold = fopen (oldname, "RB")) == NULL) retour -1; //Ouvrir le fichier de destination pour l'écriture en mode binaire si ((= fnew fopen (newname, "WB")) == NULL) {fclose (fois); retourner -1; } //Lire un octet à la fois de la source, si la fin du fichier //n'a pas été atteint, écrire l'octet à la destination while
(1) {c = fgetc (fois); if (! feof (fold)) fputc (c, fnew); pause d'autre; } Fclose (fnew); fclose (fois); return 0; } ------------------------------- Testfour.
txt --------------- --------------------- ------------------ LINUX LOR! -------- ---------------- ------------ FEDORA 3, gcc xxx ----------------- --- ouverture, la lecture, l'écriture d'une ligne de caractères -------------------------------------- -------------- Ce fichier est testfour.txt. Le contenu de ce fichier sera lu ligne par ligne de caractères jusqu'à pas plus la ligne de caractère trouvé. Ensuite, ce sera la sortie à l'écran et sera également copié de déposer testhree.txt. Vérifiez le contenu du fichier testhree.txt ...
--------------------------------------- ------------- ------------------BONNE JOURNÉE--------------- ---- ---------------------------------------------- --------------------------------- /*************** readline .c ************ /* Lire et écrire une ligne à la fois * /#include #include énumération {success, fail, MAX_LEN = 100}; /* prototype de fonction pour la lecture et écrit par la ligne ... * /LineReadWrite void (FILE * aileron, FILE * fout); int main (void) {FILE * fptr1, * fptr2; /* fichier testhree.txt est situé au répertoire courant.
vous pouvez mettre ce fichier à un endroit quelconque à condition que vous fournissez le chemin complet, même pour testfour.txt * /char filename1 [] = "testhree.txt"; carboniser filename2 [] = "testfour.txt"; omble reval = SUCCÈS; /* ouverture testhree.txt fichier en écriture, en cas de défaut ... * /if ((fptr1 = fopen (filename1, "w")) == NULL) {printf ("Problème, ne peut pas ouvrir% s en écriture test. \\ n ", filename1); Reval = FAIL; } /* Test ouverture testfour.txt fichier en lecture, si sûr ...
* /else if ((fptr2 = fopen (filename2, "r")) == NULL) {printf ("Problème, ne peut pas ouvrir% s en lecture . \\ n ", filename2); Reval = FAIL; } /* Si l'ouverture de l'écriture et de la lecture vient de succès, faire ... * /else {/* appel de fonction pour lire et écrire, ligne par ligne ... * /LineReadWrite (fptr2, fptr1); /* fermer un flux deux fichiers ... * /if (fclose (fptr1) == 0) printf ("% s fermées avec succès. \\ n", filename1); si (fclose (fptr2) == 0) printf ("fermé avec succès \\ n% s.
", filename2); } Return reval; } /* Définition de la fonction de la ligne de lecture, écriture * /vide LineReadWrite (FILE * aileron, FILE * fout) {/* variable locale ... * /char buff [MAX_LEN]. while (! fgets (buff, MAX_LEN, FIN) = NULL) {/* écrire dans le fichier ... * /fputs (buff, fout); /* écriture à l'écran ... * /printf ("% s", chamois); }} ------------------------------------------------ ---------------------------------------------- ////////////rwbinary.
c////////////////FEDORA 3, gcc xxx ///////lecture, l'écriture, rembobinage et données binaires #include énumération {success, fail, MAX_NUM = 5}; //fonctions prototypes ... Datawrite void (FILE * fout); annuler DataRead (FILE * FIN); int ErrorMsg (char * str); main (void) {FILE * fptr int; //fichiers de type binaire ... filename char [] = "/testo1/testo2/teseight.bin"; int reval = SUCCÈS; //test pour la création, l'ouverture du fichier binaire pour l'écriture ...
if ((fptr = fopen (nom de fichier, "WB +")) == NULL) {reval = ErrorMsg (nom de fichier); } Else {//Ecrire les données dans le fichier teseight.bin Datawrite (fptr); //réinitialiser l'indicateur de position du fichier ... rewind (fptr); //lire les données ... DataRead (fptr); //fermer le flux de fichiers ...
si (fclose (fptr) == 0) printf ("succès fermé \\ n% s", nom de fichier); } Return reval; } //Datawrite () définition de la fonction vide Datawrite (fichier * fout) {int i; à double buff [MAX_NUM] = {145,23, 589,69, 122,12, 253,21, 987,234}; printf ("La taille de buff:% d octets \\ n", sizeof (buff)); for (i = 0; i {printf ("% 5.
2f \\ n", chamois [i]); fwrite (& buff [i], sizeof (double), 1, fout);}} //DataRead () définition de fonction annuler DataRead (FILE * FIN) {int i; doubles x; printf ("\\ nReread du fichier binaire: \\ n"); for (i = 0; i {fread (& x, sizeof (double), (size_t) 1 , FIN); printf ("% 5.2f \\ n", x);}} //ErrorMsg () définition de la fonction int ErrorMsg (char * str) {printf ("Impossible d'ouvrir% s. \\ n", str); retour ÉCHOUER; } ====================================================================================================;>;>.h>.h>.h>.h>.h>.h>.h>.h>.h>;>.h>.h>.h>.h>;>;>.h>.h>.h>.h>.h>.h>.h>.
h>.h>.h>.h>.h>.h>.h>