Fichier texte en c c. Ouvrez un fichier à l'aide de la fonction open. Inclure et récupérer des opérateurs

Mots clés: Fichiers texte, fopen, fclose, feof, setbuf, setvbuf, fflush, fgetc, fprintf, fscanf, fgets, flux tamponné, flux non tamponné.

Travailler avec des fichiers texte

Travailler avec un fichier texte est similaire à travailler avec une console : en utilisant des fonctions d'entrée formatées, nous sauvegardons des données dans un fichier, en utilisant des fonctions de sortie formatées, nous lisons des données à partir d'un fichier. Il y a beaucoup de nuances que nous examinerons plus tard. Les principales opérations à effectuer sont

• 1. Ouvrez le fichier pour pouvoir vous y référer. En conséquence, il est possible d'ouvrir pour la lecture, l'écriture, la lecture et l'écriture, la réécriture ou l'écriture jusqu'à la fin du fichier, etc. Lorsque vous ouvrez un fichier, un tas d'erreurs peuvent également se produire - le fichier peut ne pas exister, il peut s'agir du mauvais type de fichier, vous n'êtes peut-être pas autorisé à travailler avec le fichier, etc. Tout cela doit être pris en compte.
• 2. Travailler directement avec le fichier - écriture et lecture. Il faut aussi rappeler ici que nous ne travaillons pas avec de la mémoire vive, mais avec un flux bufferisé, qui ajoute ses propres spécificités.
• 3. Fermez le fichier. Étant donné que le fichier est une ressource externe au programme, si vous ne le fermez pas, il continuera à se bloquer en mémoire, peut-être même après la fermeture du programme (par exemple, il ne sera pas possible de supprimer fichier ouvert ou apporter des modifications, etc.). De plus, il est parfois nécessaire de ne pas fermer, mais de "rouvrir" le fichier afin, par exemple, de changer le mode d'accès.

De plus, il existe un certain nombre de tâches lorsque nous n'avons pas besoin d'accéder au contenu d'un fichier : renommer, déplacer, copier, etc. Malheureusement, la norme C ne fournit pas de description des fonctions pour ces besoins. Ils sont, bien entendu, disponibles pour chacune des implémentations du compilateur. La lecture du contenu d'un répertoire (dossier, répertoire) est aussi un accès à un fichier, car un dossier lui-même est un fichier avec des méta-informations.

Parfois, il est nécessaire d'effectuer certaines opérations auxiliaires : se déplacer à l'emplacement souhaité dans le fichier, mémoriser la position actuelle, déterminer la longueur du fichier, etc.

Un objet FILE est requis pour travailler avec un fichier. Cet objet stocke l'ID du flux de fichiers et les informations dont vous avez besoin pour le manipuler, y compris un pointeur vers sa mémoire tampon, un indicateur de position de fichier et des indicateurs d'état.

L'objet FILE est lui-même une structure, mais ses champs ne doivent pas être accédés. Un programme portable doit traiter le fichier comme un objet abstrait qui permet d'accéder au flux de fichiers.

La création et l'allocation de mémoire pour un objet de type FICHIER s'effectuent à l'aide des fonctions fopen ou tmpfile (il y en a d'autres, mais nous nous intéresserons uniquement à celles-ci).

La fonction fopen ouvre un fichier. Il prend deux arguments - une chaîne avec l'adresse du fichier et une chaîne avec le mode d'accès au fichier. Le nom du fichier peut être absolu ou relatif. fopen renvoie un pointeur vers un objet FILE qui peut être utilisé pour accéder davantage au fichier.

FICHIER * fopen (const char * nom de fichier, const char * mode);

Par exemple, ouvrons un fichier et écrivons Hello World dessus

#comprendre #comprendre #comprendre void main() (// En utilisant la variable file nous accéderons au fichier FILE * file; // Ouvrir un fichier texte avec les autorisations d'écriture file = fopen ("C: /c/test.txt", "w + t") ; // Écrire dans le fichier fprintf (fichier, "Hello, World!"); // Fermer le fichier fclose (fichier); getch ();)

La fonction fopen elle-même alloue de la mémoire à l'objet, le nettoyage est effectué par la fonction fclose. Il est obligatoire de fermer le dossier, il ne se fermera pas tout seul.

La fonction fopen permet d'ouvrir un fichier en mode texte ou binaire. La valeur par défaut est le texte. Le mode d'accès peut être le suivant

Si vous devez ouvrir un fichier en mode binaire, alors la lettre b est ajoutée à la fin de la ligne, par exemple, "rb", "wb", "ab", ou, pour le mode mixte, "ab +", « wb + », « ab + ». Au lieu de b, vous pouvez ajouter la lettre t, puis le fichier s'ouvrira en mode texte. Cela dépend de la mise en œuvre. Dans la nouvelle norme C (2011), la lettre x signifie que la fonction fopen devrait échouer si le fichier existe déjà. Complétons notre ancien programme : rouvrir le fichier et considérer que nous y avons écrit.

#comprendre #comprendre #comprendre void main () (FILE * file; char buffer; file = fopen ("C: /c/test.txt", "w"); fprintf (file, "Hello, World!"); fclose (file); file = fopen ("C: /c/test.txt", "r"); fgets (tampon, 127, fichier); printf ("% s", tampon); fclose (fichier); getch ();)

Vous auriez pu utiliser fscanf au lieu de fgets, mais rappelez-vous qu'il ne peut lire qu'une ligne jusqu'au premier espace.
fscanf (fichier, "% 127s", tampon);

De plus, au lieu d'ouvrir et de fermer le fichier, vous pouvez utiliser la fonction freopen, qui "rouvre" le fichier avec de nouvelles autorisations.

#comprendre #comprendre #comprendre void main () (FILE * file; char buffer; file = fopen ("C: /c/test.txt", "w"); fprintf (file, "Hello, World!"); freopen ("C: / c / test.txt "," r ", fichier); fgets (tampon, 127, fichier); printf ("% s ", tampon); fclose (fichier); getch ();)

Les fonctions fprintf et fscanf ne diffèrent de printf et scanf que par le fait qu'elles prennent comme premier argument un pointeur vers un FICHIER vers lequel elles imprimeront ou à partir desquelles elles liront des données. Il convient d'ajouter ici tout de suite que les fonctions printf et scanf peuvent être remplacées sans aucun problème par les fonctions fprintf et fscanf. Dans le système d'exploitation (nous considérons les systèmes d'exploitation les plus courants et les plus adéquats), il existe trois flux standard : sortie standard stdout, entrée standard stdin et sortie d'erreur standard stderr. Ils s'ouvrent automatiquement au démarrage de l'application et sont associés à la console. Exemple

#comprendre #comprendre #comprendre void main () (int a, b; fprintf (stdout, "Entrez deux nombres \ n"); fscanf (stdin, "% d", & a); fscanf (stdin, "% d", & b); si (b == 0) (fprintf (stderr, "Erreur : diviser par zéro");) else (fprintf (stdout, "% .3f", (float) a / (float) b);) getch ();)

Erreur d'ouverture de fichier

Si l'appel à fopen échoue, il renverra NULL. Les erreurs lors du travail avec des fichiers sont assez courantes, donc chaque fois que nous ouvrons un fichier, nous devons vérifier le résultat du travail.

#comprendre #comprendre #comprendre #define ERROR_OPEN_FILE -3 void main () (FILE * file; char buffer; file = fopen ("C: /c/test.txt", "w"); if (file == NULL) (printf ("Error opening file "); getch (); exit (ERROR_OPEN_FILE);) fprintf (fichier," Hello, World! "); freopen (" C: /c/test.txt "," r ", file); if (file = = NULL) (printf ("Erreur d'ouverture du fichier"); getch (); exit (ERROR_OPEN_FILE);) fgets (tampon, 127, fichier); printf ("% s", tampon); fclose (fichier); getch () ;)

Le problème est causé par le cas où plusieurs fichiers sont ouverts à la fois : si l'un d'entre eux ne peut pas être ouvert, alors le reste doit également être fermé.

FICHIER * inputFile, * outputFile; non signé m, n; non signé i, j ; inputFile = fopen (INPUT_FILE, READ_ONLY); if (inputFile == NULL) (printf ("Erreur d'ouverture du fichier% s", INPUT_FILE); getch (); exit (3);) outputFile = fopen (OUTPUT_FILE, WRITE_ONLY); if (outputFile == NULL) (printf ("Erreur d'ouverture du fichier% s", OUTPUT_FILE); getch (); if (inputFile! = NULL) (fclose (inputFile);) exit (4);) ...

Dans des cas simples, vous pouvez agir de front, comme dans le morceau de code précédent. Dans les cas plus complexes, on utilise des méthodes qui remplacent RAII de C++ : wrappers, ou fonctionnalités de compilateur (nettoyage dans GCC), etc.

Données de mise en mémoire tampon

Comme mentionné précédemment, lorsque nous sortons des données, elles sont d'abord placées dans un tampon. Le tampon est vidé

• 1) S'il est plein
• 2) Si le flux est fermé
• 3) Si on indique explicitement qu'il faut vider le buffer (il y a aussi des exceptions ici :)).
• 4) Également effacé si le programme s'est terminé avec succès. Dans le même temps, tous les dossiers sont fermés. S'il y a une erreur d'exécution, cela peut ne pas se produire.

Vous pouvez forcer le déchargement du buffer en appelant la fonction fflush (File *). Regardons deux exemples - avec et sans nettoyage.

#comprendre #comprendre #comprendre void main () (FILE * file; char c; file = fopen ("C: /c/test.txt", "w"); do (c = getch (); fprintf (file, "% c", c ); fprintf (stdout, "% c", c); // fflush (fichier);) while (c! = "q"); fclose (fichier); getch ();)

Décommentez l'appel fflush. Au moment de l'exécution, ouvrez un fichier texte et observez le comportement.

Vous pouvez affecter vous-même un tampon de fichier en définissant votre propre taille. Cela se fait à l'aide de la fonction

Void setbuf (FILE * stream, char * buffer);

qui prend un FICHIER déjà ouvert et un pointeur vers un nouveau tampon. La taille du nouveau tampon doit être au moins BUFSIZ (par exemple, sur le poste de travail BUFSIZ est de 512 octets). Si vous passez NULL comme tampon, le flux ne sera plus tamponné. Vous pouvez également utiliser la fonction

Int setvbuf (FILE * stream, char * buffer, int mode, size_t size);

qui prend un tampon de taille arbitraire. Le mode peut prendre les valeurs suivantes

• _IOFBF- mise en mémoire tampon complète. Les données sont écrites dans le fichier lorsqu'il est plein. En lecture, le tampon est considéré comme plein lorsqu'une opération d'entrée est demandée et le tampon est vide.
• _IOLBF- tamponnage linéaire. Les données sont écrites dans le fichier lorsqu'il est plein ou lorsqu'un caractère de nouvelle ligne est rencontré. A la lecture, le tampon est rempli jusqu'à un caractère de nouvelle ligne lorsqu'une opération de saisie est demandée et le tampon est vide.
• _IONBF- pas de mise en mémoire tampon. Dans ce cas, les paramètres size et buffer sont ignorés.

Exemple : définissons notre propre tampon et voyons comment la lecture d'un fichier est effectuée. Que le fichier soit court (quelque chose comme Hello, World!), Et nous le lisons caractère par caractère

#comprendre #comprendre #comprendre void main () (FILE * input = NULL; char c; char buffer = (0); input = fopen ("D: /c/text.txt", "rt"); setbuf (input, buffer); while ( ! feof (entrée)) (c = fgetc (entrée); printf ("% c \ n", c); printf ("% s \ n", buffer); _getch ();) fclose (entrée);)

Vous pouvez voir que les données sont déjà dans le tampon. La lecture caractère par caractère est déjà effectuée à partir du tampon.

feof

Fonction int feof (FILE * stream); renvoie vrai si la fin du fichier a été atteinte. Cette fonction est utile lorsque vous devez parcourir l'intégralité du fichier du début à la fin. Qu'il y ait un fichier avec du contenu textuel text.txt. Nous lisons le fichier caractère par caractère et l'affichons.

#comprendre #comprendre #comprendre void main () (FILE * input = NULL; char c; input = fopen ("D: /c/text.txt", "rt"); if (input == NULL) (printf ("Erreur d'ouverture du fichier") ; _getch (); exit (0);) while (! feof (entrée)) (c = fgetc (entrée); fprintf (stdout, "% c", c);) fclose (entrée); _getch ();)

Tout irait bien, seule la fonction feof ne fonctionne pas correctement... Ceci est dû au fait que la notion de "fin de fichier" n'est pas définie. Lors de l'utilisation de feof, une erreur se produit souvent lorsque les dernières données lues sont sorties deux fois. Cela est dû au fait que les données sont écrites dans le tampon d'entrée, la dernière lecture se produit avec une erreur et la fonction renvoie l'ancienne valeur lue.

#comprendre #comprendre #comprendre void main () (FILE * input = NULL; char c; input = fopen ("D: /c/text.txt", "rt"); if (input == NULL) (printf ("Erreur d'ouverture du fichier") ; _getch (); exit (0);) while (! feof (entrée)) (fscanf (entrée, "% c", & c); fprintf (stdout, "% c", c);) fclose (entrée) ; _get ();)

Cet exemple échouera (très probablement) et produira deux fois le dernier caractère du fichier.

La solution est de ne pas utiliser feof. Par exemple, stockez le nombre total d'enregistrements ou profitez du fait que fscanf, etc., renvoie généralement le nombre de valeurs correctement lues et mises en correspondance.

#comprendre #comprendre #comprendre void main () (FILE * input = NULL; char c; input = fopen ("D: /c/text.txt", "rt"); if (input == NULL) (printf ("Erreur d'ouverture du fichier") ; _getch (); exit (0);) while (fscanf (input, "% c", & c) == 1) (fprintf (stdout, "% c", c);) fclose (input); _getch ( ) ;)

Exemples de

1. Deux nombres sont écrits dans un seul fichier - les dimensions du tableau. Remplissons le deuxième fichier avec un tableau de nombres aléatoires.

#comprendre #comprendre #comprendre #comprendre // Noms de fichiers et autorisations #define INPUT_FILE "D: /c/input.txt" #define OUTPUT_FILE "D: /c/output.txt" #define READ_ONLY "r" #define WRITE_ONLY "w" // Valeur maximale pour le tableau size #define MAX_DIMENSION 100 // Erreur lors de l'ouverture du fichier #define ERROR_OPEN_FILE -3 void main () (FILE * inputFile, * outputFile; unsigned m, n; unsigned i, j; inputFile = fopen (INPUT_FILE, READ_ONLY); if ( inputFile = = NULL) (printf ("Erreur d'ouverture du fichier% s", INPUT_FILE); getch (); exit (ERROR_OPEN_FILE);) outputFile = fopen (OUTPUT_FILE, WRITE_ONLY); if (outputFile == NULL) (printf ("Erreur d'ouverture du fichier % s ", OUTPUT_FILE); getch (); // Si le fichier a été ouvert en lecture, alors il doit être fermé if (inputFile! = NULL) (fclose (inputFile);) exit (ERROR_OPEN_FILE);) fscanf (inputFile, "% ud% ud", & m, & n); si (m> MAX_DIMENSION) (m = MAX_DIMENSION;) si (n> MAX_DIMENSION) (n = MAX_DIMENSION;) srand (temps (NULL)); pour (i = 0 ; je< n; i++) { for (j = 0; j < m; j++) { fprintf(outputFile, "%8d ", rand()); } fprintf(outputFile, "\n"); } //Закрываем файлы fclose(inputFile); fclose(outputFile); }

2. L'utilisateur copie le fichier et sélectionne d'abord le mode de fonctionnement : le fichier peut être à la fois sorti sur la console et copié dans un nouveau fichier.

#comprendre #comprendre #comprendre #define ERROR_FILE_OPEN -3 void main () (FILE * origin = NULL; FILE * output = NULL; char nom de fichier; int mode; printf ("Entrez le nom de fichier :"); scanf ("% 1023s", nom de fichier); origin = fopen (nom de fichier, "r"); if (origine == NULL) (printf ("Erreur d'ouverture du fichier% s", nom de fichier); getch (); exit (ERROR_FILE_OPEN);) printf ("enter mode:"); scanf ( "% d", & mode); if (mode == 1) (printf ("Entrez le nom de fichier :"); scanf ("% 1023s", nom de fichier); output = fopen (nom de fichier, "w"); if (sortie = = NULL) (printf ("Erreur d'ouverture du fichier% s", nom du fichier); getch (); fclose (origine); exit (ERROR_FILE_OPEN);)) else (output = stdout;) while (! Feof (origine)) ( fprintf (sortie, "% c", fgetc (origine));) fclose (origine); fclose (sortie); getch ();)

3. L'utilisateur saisit les données à partir de la console et elles sont écrites dans le fichier jusqu'à ce que la touche esc soit enfoncée. Vérifiez le programme et voyez. comment il se comporte si vous tapez backspace : ce qui est sorti dans un fichier et ce qui est sorti dans la console.

#comprendre #comprendre #comprendre #define ERROR_FILE_OPEN -3 void main () (FILE * output = NULL; char c; output = fopen ("D: /c/test_output.txt", "w + t"); if (output == NULL) (printf ("Erreur d'ouverture du fichier"); _getch (); exit (ERROR_FILE_OPEN);) pour (;;) (c = _getch (); if (c == 27) (break;) fputc (c, sortie); fputc ( c, sortie standard );) fclose (sortie );)

4. Le fichier contient des nombres entiers. Trouvez-en le maximum. Profitons du fait que la fonction fscanf renvoie le nombre d'objets lus et appariés correctement. Le chiffre 1 doit être retourné à chaque fois.

#comprendre #comprendre #comprendre #define ERROR_FILE_OPEN -3 void main () (FILE * input = NULL ; int num, maxn, hasRead ; input = fopen ("D: /c/input.txt", "r"); if (input == NULL) (printf ("Erreur d'ouverture du fichier"); _getch (); exit (ERROR_FILE_OPEN);) maxn = INT_MIN; hasRead = 1; while (hasRead == 1) (hasRead = fscanf (input, "% d", & num) ; if (hasRead! = 1) (continue;) if (num>

Une autre solution est de lire les nombres jusqu'à la fin du fichier.

#comprendre #comprendre #comprendre #comprendre #define ERROR_FILE_OPEN -3 void main () (FILE * input = NULL ; int num, maxn, hasRead ; input = fopen ("D: /c/input.txt", "r"); if (input == NULL) (printf ("Erreur d'ouverture du fichier"); _getch (); exit (ERROR_FILE_OPEN);) maxn = INT_MIN; while (! feof (input)) (fscanf (input, "% d", & num); if (num> maxn ) (maxn = num;)) printf ("max nombre =% d", maxn); fclose (entrée); _getch ();)

5. Le fichier contient des mots : mot russe, tabulation, mot anglais, sur plusieurs lignes. L'utilisateur saisit un mot anglais, il faut afficher le mot russe.

Le fichier de traduction ressemble à ceci

Soleil Soleil
stylo crayon
stylo à bille crayon
porte porte
fenêtre fenêtre
chaise chaise
fauteuil chaise

et enregistré dans l'encodage cp866 (OEM 866). Il est important que la dernière paire de mots se termine également par un saut de ligne.

L'algorithme est le suivant - nous lisons la ligne du fichier, trouvons le signe de tabulation dans la ligne, remplaçons le signe de tabulation par zéro, copions le mot russe du tampon, copions le mot anglais du tampon, vérifions l'égalité.

#comprendre #comprendre #comprendre #comprendre #define ERROR_FILE_OPEN -3 void main () (FILE * input = NULL; char buffer; char enWord; char ruWord; char usrWord; index non signé; int length; int wasFound; input = fopen ("D: /c/input.txt "," r "); if (input == NULL) (printf (" Erreur d'ouverture du fichier "); _getch (); exit (ERROR_FILE_OPEN);) printf (" enter word: "); fgets (usrWord, 127, stdin ); wasFound = 0; while (! feof (entrée)) (fgets (tampon, 511, entrée); longueur = strlen (tampon); for (index = 0; index< length; index++) { if (buffer == "\t") { buffer = "\0"; break; } } strcpy(ruWord, buffer); strcpy(enWord, &buffer); if (!strcmp(enWord, usrWord)) { wasFound = 1; break; } } if (wasFound) { printf("%s", ruWord); } else { printf("Word not found"); } fclose(input); _getch(); }

6. Comptez le nombre de lignes dans le fichier. Lisons le fichier caractère par caractère, en comptant le nombre de caractères "\ n" jusqu'à ce que nous rencontrions le caractère EOF. EOF est un caractère spécial qui indique que la saisie est terminée et qu'il n'y a plus de données à lire. La fonction renvoie une valeur négative en cas d'erreur.
REMARQUE : EOF est un entier, vous devez donc utiliser un entier pour lire les caractères. De plus, la valeur EOF n'est pas définie par la norme.

#define _CRT_SECURE_NO_WARNINGS #include #comprendre #comprendre int cntLines (const char * filename) (int lines = 0; int any; // tout type int, car EOF est de type int! FILE * f = fopen (filename, "r"); if (f == NULL ) (return -1;) do (any = fgetc (f); // printf ("% c", any); // debug if (any == "\ n") (lignes ++;)) while ( any! = EOF); ​​​​fclose (f); return lines;) void main () (printf ("% d \ n", cntLines ("C: /c/file.txt")); _getch (); )

Ru-Cyrl 18- tutoriel Sypachev S.S. 1989-04-14 [email protégé] Stépan Sypachevétudiants

Toujours pas clair ? - écrire des questions dans la boîte aux lettres

Fichiers texte

Envisageons de travailler avec un fichier texte en C à l'aide d'un exemple. Créez un fichier texte sur le disque C appelé TextFile.txt. Tapez les lignes suivantes dans ce fichier :

Chaîne_1 123 Chaîne_11, 456
Chaîne_2
Chaîne_3

Enregistrez le fichier.

Et voici le code d'un programme C qui ouvre notre fichier et en lit les lignes :

/ * * Auteur : @author Subbotin B.P..h> #include #define LEN 50 int main (void) (puts ("Opérations sur les fichiers texte"); char cArray; FILE * pTextFile = fopen ("C: \\ TextFile.txt", "r"); if (pTextFile == NULL) (puts ("Problèmes"); return EXIT_FAILURE;) while (fgets (cArray, LEN, pTextFile)! = NULL) (printf ("% s", cArray);) fclose (pTextFile); return EXIT_SUCCESS;)

Pour ouvrir un fichier texte en C, utilisez la fonction fopen :

FICHIER * pTextFile = fopen ("C: \\ TextFile.txt", "r");

le premier argument de fopen pointe vers un fichier, et le second indique que le fichier est ouvert pour lecture.

Nous lisons les lignes à l'aide de la fonction fgets :

fgets (cArray, LEN, pTextFile);

le premier argument de fgets pointe vers un tableau de caractères qui stockera les chaînes résultantes, le deuxième argument est le nombre maximum de caractères à lire et le troisième est notre fichier.

Après avoir terminé le travail avec le fichier, il doit être fermé :

fclose (pFichierTexte);

On a:

Les lettres russes dans les lignes passent également.

Au fait, j'ai fait ce programme dans Eclipse. Vous pouvez voir comment travailler avec C/C++ dans Eclipse.

Nous avons donc ouvert et lu les données d'un fichier texte.

Nous allons maintenant apprendre à créer par programmation un fichier texte et à y écrire des données.

/ * Auteur : @author Subbotin B.P..h> #include int main (void) (FILE * pTextFile = fopen ("C: \\ TextFileW.txt", "w"); char * cString = "Ceci est une chaîne"; char cNewLine = "\ n"; int nVal = 123 ; if (pTextFile == NULL) (puts ("Problèmes"); return EXIT_FAILURE;) fprintf (pTextFile, "% s% c", cString, cNewLine); fprintf (pTextFile, "% d", nVal); return EXIT_SUCCESS ;)

Créez un fichier texte pour y écrire des données :

FICHIER * pTextFile = fopen ("C: \\ TextFileW.txt", "w");

si le fichier existe déjà, il sera ouvert et toutes les données qu'il contient seront supprimées.

La chaîne C cString et le nombre nVal sont écrits par le programme dans un fichier texte. cNewLine est juste un saut de ligne.

Nous écrivons les données dans un fichier texte à l'aide de la fonction fprintf :

fprintf (pTextFile, "% s% c", cString, cNewLine);

le premier argument ici est notre fichier, le deuxième est une chaîne de format, le troisième et plus est le nombre d'arguments requis pour ce format.

Pour plus de commodité, les informations dans les périphériques de stockage sont stockées sous forme de fichiers.

Le fichier est une zone nommée de mémoire externe allouée pour stocker un tableau de données. Les données contenues dans les fichiers sont de la nature la plus variée : programmes en langage algorithmique ou machine ; les données initiales pour le fonctionnement des programmes ou les résultats de l'exécution des programmes ; textes arbitraires; images graphiques etc.

Répertoire (dossier, répertoire) - une collection nommée d'octets sur un support de stockage, contenant le nom des sous-répertoires et des fichiers, est utilisée dans le système de fichiers pour simplifier l'organisation des fichiers.

Système de fichiers appelé la partie fonctionnelle système opérateur, qui permet l'exécution d'opérations sur des fichiers. Des exemples de systèmes de fichiers sont FAT (FAT - File Allocation Table), NTFS, UDF (utilisé sur les CD).

Il existe trois versions principales de FAT : FAT12, FAT16 et FAT32. Ils diffèrent par la profondeur de bits des enregistrements dans la structure du disque, c'est-à-dire le nombre de bits alloués pour stocker le numéro de cluster. FAT12 est principalement utilisé pour les disquettes (jusqu'à 4 Ko), FAT16 pour les petits disques, FAT32 pour les lecteurs FLASH de grande capacité (jusqu'à 32 Go).

Considérez la structure système de fichiers en utilisant FAT32 comme exemple.

Structure de fichier FAT32

Les dispositifs de mémoire externes dans le système FAT32 n'ont pas d'adressage d'octet, mais de bloc. Les informations sont écrites sur le périphérique de mémoire externe en blocs ou en secteurs.

Un secteur est la plus petite unité adressable de stockage d'informations sur des périphériques de stockage externes. Typiquement, la taille du secteur est fixée à 512 octets. Pour augmenter l'espace d'adressage des périphériques de mémoire externes, les secteurs sont combinés en groupes appelés clusters.

Un cluster est une union de plusieurs secteurs, qui peuvent être considérés comme une unité indépendante avec certaines propriétés. La principale propriété d'un cluster est sa taille, mesurée en nombre de secteurs ou en nombre d'octets.

Le système de fichiers FAT32 a la structure suivante.

Les clusters utilisés pour l'enregistrement des fichiers sont numérotés à partir de 2. En règle générale, le cluster #2 est utilisé par le répertoire racine, et à partir du cluster #3, un tableau de données est stocké. Les secteurs utilisés pour stocker les informations présentées au-dessus du répertoire racine ne sont pas regroupés.
La taille minimale du fichier sur le disque est de 1 cluster.

Le secteur de démarrage commence par les informations suivantes :

• EB 58 90 - branche et signature inconditionnelles ;
• 4D 53 44 4F 53 35 2E 30 MSDOS5.0 ;
• 00 02 - le nombre d'octets dans le secteur (généralement 512);
• 1 octet - le nombre de secteurs dans le cluster ;
• 2 octets - le nombre de secteurs de réserve.

De plus, le secteur de démarrage contient les informations importantes suivantes :

• 0x10 (1 octet) - nombre de tables FAT (généralement 2);
• 0x20 (4 octets) - le nombre de secteurs sur le disque ;
• 0x2С (4 octets) - numéro du cluster du répertoire racine ;
• 0x47 (11 octets) - étiquette de volume ;
• 0x1FE (2 octets) - signature Secteur de démarrage(55 AA).

Le secteur d'informations du système de fichiers contient :

• 0x00 (4 octets) - signature (52 52 61 41);
• 0x1E4 (4 octets) - signature (72 72 41 61);
• 0x1E8 (4 octets) - nombre de clusters libres, -1 si inconnu ;
• 0x1EC (4 octets) - numéro du dernier cluster enregistré ;
• 0x1FE (2 octets) - signature (55 AA).

Le FAT contient des informations sur l'état de chaque cluster sur le disque. Les 2 octets inférieurs du FAT stockent F8 FF FF 0F FF FF FF FF (ce qui correspond à l'état des clusters 0 et 1, qui sont physiquement absents). De plus, l'état de chaque cluster contient le numéro du cluster dans lequel le fichier actuel continue ou les informations suivantes :

• 00 00 00 00 - le cluster est libre ;
• FF FF FF 0F - fin du fichier courant.

• 8 octets - nom de fichier ;
• 3 octets - extension de fichier ;

Le répertoire racine contient un ensemble d'enregistrements d'informations 32 bits pour chaque fichier, contenant les informations suivantes :

Lorsque vous travaillez avec des noms de fichiers longs (y compris des noms russes), le nom de fichier est codé dans le système de codage UTF-16. Dans ce cas, 2 octets sont alloués pour encoder chaque caractère. Dans ce cas, le nom du fichier est écrit sous la forme de la structure suivante :

• 1 octet de séquence ;
• 10 octets contiennent les 5 caractères les moins significatifs du nom de fichier ;
• attribut 1 octet ;
• 1 octet réservé ;
• 1 octet - somme de contrôle nom DOS ;
• 12 octets contiennent les 3 caractères les moins significatifs du nom de fichier ;
• 2 octets - numéro du premier cluster ;
• autres caractères du nom long.

Travailler avec des fichiers en langage C

Pour le programmeur, un fichier ouvert est représenté comme une séquence de données en cours de lecture ou d'écriture. Lorsqu'un fichier est ouvert, il est associé à Flux d'E/S... Les informations de sortie sont écrites dans le flux, les informations d'entrée sont lues à partir du flux.

Lorsqu'un flux est ouvert pour les E/S, il s'associe à une structure standard de type FILE, qui est définie dans stdio.h. La structure FILE contient les informations nécessaires sur le fichier.

Le fichier est ouvert à l'aide de la fonction fopen (), qui renvoie un pointeur vers une structure FILE, qui peut être utilisée pour des opérations ultérieures avec le fichier.

FICHIER * fopen (nom, type);

• "r" - ouvre un fichier en lecture (le fichier doit exister);
• "w" - ouvre un fichier vide pour l'écriture ; si le fichier existe, alors son contenu est perdu ;
• "a" - ouvre le fichier pour l'écriture jusqu'à la fin (pour l'ajout); le fichier est créé s'il n'existe pas ;
• "r +" - ouvre un fichier en lecture et en écriture (le fichier doit exister);
• "w +" - ouvre un fichier vide pour la lecture et l'écriture ; si le fichier existe, alors son contenu est perdu ;
• "a +" - ouvre le fichier pour lecture et ajout, si le fichier n'existe pas, alors il est créé.

La valeur de retour est un pointeur vers le flux ouvert. Si une erreur est rencontrée, NULL est renvoyé.

La fonction fclose() ferme le ou les flux associés aux fichiers ouverts avec fopen(). Le flux à fermer est déterminé par l'argument de la fonction fclose().

Valeur renvoyée : valeur 0, si le flux a été fermé avec succès ; EOF constant si une erreur s'est produite.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#comprendre
int main () (
FICHIER * fp;
nom de caractère = "mon.txt" ;
if ((fp = fopen (nom, "r")) == NULL)
{
printf ( "Impossible d'ouvrir le fichier");
getchar ();
renvoie 0 ;
}
// ouvre le fichier avec succès
... // actions requises sur les données
ffermer (fp);
getchar ();
renvoie 0 ;
}

Lire un caractère dans un fichier:

char fgetc (flux);

Ecrire un caractère dans un fichier:

fputc (caractère, flux);

Les arguments de la fonction sont un caractère et un pointeur vers un flux de type FICHIER. La fonction renvoie le code du caractère lu.

Les fonctions fscanf () et fprintf () sont similaires aux fonctions scanf () et printf (), mais elles fonctionnent avec des fichiers de données et ont un pointeur de fichier comme premier argument.

fscanf (flux, "Format d'entrée", arguments);

Pour le programmeur, un fichier ouvert est représenté comme une séquence de données en cours de lecture ou d'écriture. Lorsqu'un fichier est ouvert, il est associé à Flux d'E/S ... Les informations de sortie sont écrites dans le flux, les informations d'entrée sont lues à partir du flux.

Lorsqu'un flux est ouvert pour les E/S, il s'associe à une structure standard de type FILE, qui est définie dans stdio.h. La structure FILE contient les informations nécessaires sur le fichier.

Le fichier est ouvert à l'aide de la fonction fopen (), qui renvoie un pointeur vers une structure FILE, qui peut être utilisée pour des opérations ultérieures avec le fichier.

FICHIER * fopen (nom, type);

name - le nom du fichier à ouvrir (y compris le chemin),
type est un pointeur vers une chaîne de caractères qui détermine comment accéder au fichier :

· "R" - ouvre un fichier en lecture (le fichier doit exister);

· "W" - ouvre un fichier vide pour l'écriture ; si le fichier existe, alors son contenu est perdu ;

· "A" - ouvre le fichier pour l'écriture jusqu'à la fin (pour l'ajout); le fichier est créé s'il n'existe pas ;

· "R +" - ouvre un fichier en lecture et en écriture (le fichier doit exister);

· "W +" - ouvre un fichier vide pour la lecture et l'écriture ; si le fichier existe, alors son contenu est perdu ;

· "A +" - ouvre le fichier pour lecture et ajout, si le fichier n'existe pas, alors il est créé.

La valeur de retour est un pointeur vers le flux ouvert. Si une erreur est rencontrée, NULL est renvoyé.

La fonction fclose() ferme le ou les flux associés aux fichiers ouverts avec fopen(). Le flux à fermer est déterminé par l'argument de la fonction fclose().

Valeur renvoyée : valeur 0, si le flux a été fermé avec succès ; EOF constant si une erreur s'est produite.

#comprendre
int main ()

nom de caractère = "mon.txt" ;

if (fp = fopen (nom, "r") ! = NULL)

// était-il possible d'ouvrir le fichier ?
... // actions requises sur les données

else printf ("Impossible d'ouvrir le fichier");

Lire un caractère dans un fichier:

char fgetc (flux);

L'argument de fonction est un pointeur vers un flux de type FICHIER. La fonction renvoie le code du caractère lu. Si la fin du fichier est atteinte ou si une erreur se produit, la constante EOF est renvoyée.
Ecrire un caractère dans un fichier:

fputc (caractère, flux);

Les arguments de la fonction sont un caractère et un pointeur vers un flux de type FICHIER. La fonction renvoie le code du caractère lu.

Les fonctions fscanf () et fprintf () sont similaires aux fonctions scanf () et printf (), mais elles fonctionnent avec des fichiers de données et ont un pointeur de fichier comme premier argument.

fscanf (flux, "Format d'entrée", arguments);
fprintf (flux, "Format de sortie", arguments);

Les fonctions fgets() et fputs() sont destinées à l'entrée/sortie de chaînes ; elles sont analogues aux fonctions gets() et puts() pour travailler avec des fichiers.

fgets (pointeur par ligne, nombre de caractères, flux);

Les caractères sont lus à partir du flux jusqu'à ce qu'un caractère de nouvelle ligne "\ n" soit lu, qui est inclus dans la chaîne, ou jusqu'à la fin du flux EOF ou jusqu'à ce que le nombre maximum de caractères ait été lu. Le résultat est placé dans un pointeur vers une chaîne et se termine par un caractère nul "\ 0". La fonction renvoie l'adresse de la chaîne.

fputs (Pointer To String, flux);

Copie une chaîne dans le flux à partir de la position actuelle. Le caractère nul de fin n'est pas copié.
Exemple Entrez le numéro et enregistrez-le dans le fichier s1.txt. Lisez le numéro du fichier s1.txt, augmentez-le de 3 et enregistrez-le dans le fichier s2.txt.

Les fichiers permettent à l'utilisateur de lire de grandes quantités de données directement à partir du disque sans les saisir à partir du clavier. Il existe deux principaux types de fichiers : texte et binaire.

Texte les fichiers composés de n'importe quel caractère sont appelés. Ils sont organisés en lignes dont chacune se termine par " fin de ligne "... La fin du fichier lui-même est indiquée par le symbole " fin de fichier "... Lors de l'écriture d'informations dans un fichier texte, qui peut être visualisé à l'aide de n'importe quel éditeur de texte, toutes les données sont converties en un type de caractère et stockées sous forme de caractère.

V binaire fichiers, les informations sont lues et écrites sous la forme de blocs d'une certaine taille, dans lesquels des données de tout type et structure peuvent être stockées.

Pour travailler avec des fichiers, des types de données spéciaux sont utilisés, appelés ruisseaux. Couler ifstream sert à travailler avec des fichiers en mode lecture, et hors flux en mode enregistrement. Pour travailler avec des fichiers en mode écriture et lecture, utilisez le flux fstream.

Dans les programmes C ++, lorsque vous travaillez avec des fichiers texte, vous devez inclure des bibliothèques iostream et fstream.

Pour écrire des données dans un fichier texte, vous devez :

1. décris variable comme hors flux.
2. ouvert.
3. des informations de sortie dans un fichier.
4. assurez-vous de fermer le fichier.

Pour lire les données d'un fichier texte, vous devez :

1. décrire une variable de type ifstream.
2. ouvrir le fichier avec la fonction ouvert.
3. lire les informations du fichier ; lors de la lecture de chaque donnée, il est nécessaire de vérifier si la fin du fichier est atteinte.
4. fermez le fichier.

Ecrire des informations dans un fichier texte

Comme mentionné précédemment, pour commencer à travailler avec un fichier texte, vous devez décrire une variable du type hors flux... Par exemple, comme ceci :

hors flux F;

Une variable sera créée F pour écrire des informations dans un fichier. L'étape suivante consiste à ouvrir le fichier pour l'écriture. En général, l'opérateur d'ouverture de flux ressemblera à ceci :

F.ouvert("Déposer", mode);

Ici F est une variable décrite comme hors flux, déposer - nom et prénom fichier sur disque, mode- mode de travail avec le fichier ouvert. Veuillez noter que vous devez utiliser une double barre oblique lorsque vous spécifiez le nom complet du fichier. Pour accéder, par exemple, à un fichier comptes.txt, situé dans le dossier des sites sur disque ré, le programme doit indiquer : D : \\ sites \\ comptes.SMS.

Le fichier peut être ouvert dans l'un des modes suivants :

• ios :: dans- ouvrir le fichier en mode lecture de données ; mode est le mode par défaut pour les flux ifstream;
• ios :: dehors- ouvrir le fichier en mode enregistrement des données (les informations sur le fichier existant sont détruites) ; mode est le mode par défaut pour les flux hors flux;
• ios :: application- ouvrir le fichier en mode écriture de données à la fin du fichier ;
• ios :: mangé- passer à la fin d'un fichier déjà ouvert ;
• ios :: tronc- effacer le fichier, la même chose se produit en mode ios :: out ;
• ios :: nocreate- ne pas effectuer l'opération d'ouverture d'un fichier s'il n'existe pas ;
• ios :: remplacer- N'ouvre pas fichier existant.

Le paramètre mode peut être absent, dans ce cas le fichier est ouvert dans le mode par défaut pour ce flux.

Après avoir ouvert avec succès le fichier (dans n'importe quel mode) dans la variable F sera gardé vrai, autrement faux... Cela vérifiera l'exactitude de l'opération d'ouverture du fichier.

Ouvrez un fichier (par exemple, prenez le fichier D : \\ sites \\ comptes.SMS) en mode enregistrement de l'une des manières suivantes :

Après ouverture du fichier en écriture, un fichier vide sera créé, dans lequel il sera possible d'écrire des informations.

Si vous souhaitez ouvrir un fichier existant en mode réécriture, utilisez la valeur ios :: application.

Après avoir ouvert un fichier en mode écriture, vous pouvez y écrire de la même manière qu'à l'écran, mais au lieu de appareil standard Retrait cout vous devez spécifier le nom du fichier ouvert.

Par exemple, pour écrire dans le flux F variable une, l'opérateur de sortie sera :

F<