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 est associé à une structure FILE standard, définie dans stdio.h. La structure FILE contient les informations nécessaires sur le fichier.
L'ouverture d'un fichier se fait à l'aide de la fonction fopen(), qui renvoie un pointeur vers une structure de type FILE pouvant être utilisée pour les opérations ultérieures sur le fichier.
FICHIER *fopen(nom, type);
nom – nom du fichier à ouvrir (y compris le chemin),
type - pointeur vers une chaîne de caractères définissant la manière dont le fichier est accessible :
· "r" - ouvre le fichier en lecture (le fichier doit exister) ;
· "w" - ouvre un fichier vide en écriture ; si le fichier existe, son contenu est perdu ;
· "a" - ouvre le fichier pour l'écrire jusqu'à la fin (pour l'ajouter) ; le fichier est créé s'il n'existe pas ;
· "r+" - ouvre le 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, son contenu est perdu ;
· "a+" - ouvre le fichier pour lecture et ajout ; si le fichier n'existe pas, il est créé.
La valeur de retour est un pointeur vers le flux ouvert. Si une erreur est détectée, NULL est renvoyé.
La fonction fclose() ferme le ou les flux associés aux fichiers ouverts à l'aide de la fonction fopen(). Le flux à fermer est déterminé par l'argument de la fonction fclose().
Valeur de retour : valeur 0 si le flux a été fermé avec succès ; EOF constant si une erreur survient.
#inclure
int main()
char name="mon.txt";
si(fp = fopen(nom, "r")!=NULL)
// était-il possible d'ouvrir le fichier ?
... // actions requises sur les données
else printf("Échec de l'ouverture du fichier");
Lire un caractère à partir d'un fichier:
char fgetc(flux);
L'argument de la fonction est un pointeur vers un flux de type FILE. La fonction renvoie le code du caractère lu. Si la fin du fichier est atteinte ou qu'une erreur se produit, la constante EOF est renvoyée.
Écrire un symbole dans un fichier:
fputc(char, flux);
Les arguments de la fonction sont un caractère et un pointeur vers un flux de type FILE. La fonction renvoie le code du caractère lu.
Les fonctions fscanf() et fprintf() sont similaires aux fonctions scanf() et printf(), mais fonctionnent avec des fichiers de données et ont un pointeur vers le fichier comme premier argument.
fscanf(flux, "Format d'entrée", arguments);
fprintf(stream, "Format de sortie", arguments);
Les fonctions fgets() et fputs() sont conçues pour les entrées/sorties de chaînes ; elles sont analogues aux fonctions gets() et puts() pour travailler avec des fichiers.
fgets (pointeur vers la 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'à ce que le flux termine EOF ou que le nombre maximum de caractères ait été lu. Le résultat est placé dans un pointeur de chaîne et se termine par le caractère nul "\0". La fonction renvoie l'adresse de la chaîne.
fputs (pointeur vers chaîne, 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.
Auparavant, lors de la saisie et de la sortie de données, nous travaillions avec des flux standard - le clavier et le moniteur. Voyons maintenant comment le langage C implémente la réception de données à partir de fichiers et leur écriture là-bas. Avant de pouvoir effectuer ces opérations, vous devez ouvrir le fichier et y accéder.
Dans le langage de programmation C, un pointeur vers un fichier est de type FILE et sa déclaration ressemble à ceci :
FICHIER *monfichier ;
D'autre part, la fonction fopen() ouvre un fichier à l'adresse spécifiée comme premier argument en mode lecture ("r"), en mode écriture ("w") ou en mode ajout ("a") et renvoie un pointeur au programme. Par conséquent, le processus d'ouverture d'un fichier et de connexion au programme ressemble à ceci :
monfichier = fopen("hello.txt", "r");
Lors de la lecture ou de l'écriture de données dans un fichier, celui-ci est accessible via un pointeur de fichier (dans ce cas, monfichier).
Si pour une raison ou une autre (il n'y a pas de fichier à l'adresse spécifiée, l'accès à celui-ci est refusé) la fonction fopen() ne peut pas ouvrir le fichier, alors elle renvoie NULL. Dans les programmes réels, ils gèrent presque toujours une erreur d'ouverture de fichier dans la branche if, mais nous l'omettrons davantage.
La déclaration de la fonction fopen() est contenue dans le fichier d'en-tête stdio.h, elle doit donc être incluse. Également dans stdio.h, le type de structure FILE est déclaré.
Une fois le travail terminé avec un fichier, il est d'usage de le fermer pour libérer le tampon des données et pour d'autres raisons. Ceci est particulièrement important si le programme continue de s'exécuter après avoir travaillé avec le fichier. La rupture de la connexion entre un fichier externe et un pointeur vers celui-ci à partir du programme se fait à l'aide de la fonction fclose(). Un pointeur vers le fichier lui est passé en paramètre :
fclose(monfichier);
Plus d'un fichier peut être ouvert dans le programme. Dans ce cas, chaque fichier doit être associé à son propre pointeur de fichier. Cependant, si le programme travaille d'abord avec un fichier puis le ferme, le pointeur peut être utilisé pour ouvrir un deuxième fichier.
Lire et écrire dans un fichier texte
fscanf()
La fonction fscanf() a une signification similaire à la fonction scanf(), mais contrairement à elle, elle fournit une entrée formatée à partir d'un fichier plutôt qu'une entrée standard. La fonction fscanf() prend en paramètres : pointeur de fichier, chaîne de format, adresses des zones mémoire pour l'écriture des données :
fscanf(monfichier, "%s%d", str, &a);
Renvoie le nombre de données lues avec succès ou EOF. Les espaces et les caractères de nouvelle ligne sont comptés comme délimiteurs de données.
Disons que nous avons un fichier contenant la description suivante des objets :
Pommes 10 23,4 bananes 5 25,0 pain 1 10,3
#inclure
Dans ce cas, une structure et un tableau de structures sont déclarés. Chaque ligne du fichier correspond à un élément du tableau ; un élément de tableau est une structure contenant une chaîne et deux champs numériques. La boucle lit une ligne par itération. Lorsque la fin du fichier est rencontrée, fscanf() renvoie EOF et la boucle se termine.
fgets()
La fonction fgets() est similaire à la fonction gets() et effectue une saisie ligne par ligne à partir d'un fichier. Un appel à fgets() lira une ligne. Dans ce cas, vous ne pouvez pas lire la ligne entière, mais seulement une partie depuis le début. Les paramètres fgets() ressemblent à ceci :
fgets (character_array, number_of_characters_read, pointer_to_file)
Par exemple:
fgets(str, 50, monfichier)
Cet appel de fonction lira dans le fichier associé au pointeur monfichier une ligne complète de texte si sa longueur est inférieure à 50 caractères, y compris le caractère "\n", que la fonction stockera également dans un tableau. Le dernier (50ème) élément du tableau str sera le caractère "\0" ajouté par fgets() . Si la chaîne est plus longue, la fonction lira 49 caractères et écrira "\0" à la fin. Dans ce cas, "\n" ne sera pas contenu dans la ligne de lecture.
#inclure
Dans ce programme, contrairement au précédent, les données sont lues ligne par ligne dans le tableau arr. A la lecture de la ligne suivante, la précédente est perdue. La fonction fgets() renvoie NULL si elle ne parvient pas à lire la ligne suivante.
getc() ou fgetc()
La fonction getc() ou fgetc() (les deux fonctionnent) vous permet d'obtenir le caractère suivant d'un fichier.
while ((arr[ i] = fgetc (file) ) != EOF) ( if (arr[ i] == " \n") (arr[je] = " \0 " ; printf("%s \n", arr) ; je = 0 ; ) sinon je++; )arr[i] = " \0 " ; printf("%s \n", arr) ;
L'exemple de code affiche les données d'un fichier à l'écran.
Écrire dans un fichier texte
Tout comme l'entrée, la sortie vers un fichier peut être différente.
- Sortie formatée. Fonction fprintf (file_index, format_string, variables) .
- Sortie post-par-ligne. Fonction fputs(string, file_pointer) .
- Sortie caractère par caractère. Fonction fputc() ou putc(symbol, file_pointer) .
Vous trouverez ci-dessous des exemples de code qui utilisent trois méthodes de sortie de données dans un fichier.
Écriture des champs d'une structure sur chaque ligne du fichier :
fichier = fopen ("fprintf.txt" , "w" ) ; while (scanf ("%s%u%f" , shop[ i].name , & (shop[ i].qty ) , & (shop[ i].price ) ) != EOF) ( fprintf (fichier, " %s %u %.2f \n", boutique[i].nom, boutique[i].qté, boutique[i].prix) ; je++; )
Sortie ligne par ligne dans un fichier (fputs(), contrairement à puts() lui-même, ne place pas « \n » à la fin de la ligne) :
while (obtient (arr) != NULL) ( fputs (arr, fichier); fputs (" \n", déposer); )
Exemple de sortie caractère par caractère :
while ((i = getchar () ) != EOF) putc (i, file) ;
Lire et écrire dans un fichier binaire
Vous pouvez travailler avec un fichier non pas comme une séquence de caractères, mais comme une séquence d'octets. En principe, il n'est pas possible de travailler autrement avec des fichiers non texte. Cependant, vous pouvez lire et écrire dans des fichiers texte de cette façon. L'avantage de cette méthode d'accès à un fichier est la vitesse de lecture-écriture : un bloc d'information important peut être lu/écrit en un seul accès.
Lors de l'ouverture d'un fichier pour un accès binaire, le deuxième paramètre de fopen() est la chaîne "rb" ou "wb".
Le sujet du travail avec des fichiers binaires est assez complexe et nécessite une leçon distincte pour l'étudier. Ici, seules les caractéristiques des fonctions de lecture et d'écriture dans un fichier, considéré comme un flux d'octets, seront notées.
Les fonctions fread() et fwrite() prennent en paramètres :
- adresse de la zone mémoire dans laquelle les données sont écrites ou lues,
- la taille d'un modèle donné, quel que soit son type,
- la quantité de données lues de la taille spécifiée,
- index des fichiers.
Ces fonctions renvoient le nombre de données lues ou écrites avec succès. Ceux. vous pouvez « commander » la lecture de 50 données, mais n’en recevoir que 10. Il n’y aura pas d’erreur.
Un exemple d'utilisation des fonctions fread() et fwrite() :
#inclure
Ici, une tentative est faite pour lire 50 caractères du premier fichier. n stocke le nombre de caractères réellement lus. La valeur de n peut être inférieure ou égale à 50. Les données sont placées dans une ligne. La même chose se produit avec le deuxième fichier. Ensuite, la première ligne est ajoutée à la seconde et les données sont transférées dans le troisième fichier.
Résolution de problème
- Écrivez un programme qui demande à l'utilisateur le nom (adresse) d'un fichier texte, puis l'ouvre et compte le nombre de caractères et de lignes qu'il contient.
- Écrivez un programme qui écrit dans un fichier les données reçues d'un autre fichier et modifiées d'une manière ou d'une autre avant l'écriture. Chaque ligne de données obtenue à partir d'un fichier doit s'inscrire dans une structure.
La plupart des programmes informatiques fonctionnent avec des fichiers et il est donc nécessaire de créer, supprimer, écrire, lire et ouvrir des fichiers. Qu'est-ce qu'un fichier ? Un fichier est un ensemble nommé d'octets qui peuvent être stockés sur un périphérique de stockage. Eh bien, il est maintenant clair qu'un fichier désigne une certaine séquence d'octets qui a son propre nom unique, par exemple file.txt. Les fichiers portant les mêmes noms ne peuvent pas se trouver dans le même répertoire. Le nom du fichier fait référence non seulement à son nom, mais aussi à son extension, par exemple : fichier.txt et fichier.dat — fichiers différents, bien qu'ils portent les mêmes noms. Il existe un nom de fichier complet - il s'agit de l'adresse complète du répertoire de fichiers indiquant le nom du fichier, par exemple : D:\docs\file.txt. Il est important de comprendre ces concepts de base, sinon il sera difficile de travailler avec des fichiers.
Pour travailler avec des fichiers, vous devez inclure un fichier d'en-tête
Les E/S de fichier sont similaires aux E/S standard, la seule différence est que les E/S sont effectuées vers un fichier plutôt que vers l'écran. Si les E/S vers les périphériques standard sont effectuées à l'aide des objets cin et cout, alors pour organiser les E/S sur les fichiers, il suffit de créer vos propres objets qui peuvent être utilisés de la même manière que les opérateurs cin et cout.
Par exemple, vous devez créer un fichier texte et y écrire la ligne Travailler avec des fichiers en C++. Pour ce faire, vous devez suivre les étapes suivantes :
- créer un objet de classe ofstream ;
- associer un objet de classe au fichier dans lequel écrire ;
- écrire une ligne dans un fichier ;
- fermez le fichier.
Pourquoi est-il nécessaire de créer un objet ofstream plutôt qu'un objet ifstream ? Parce que vous devez écrire dans un fichier et si vous devez lire des données à partir d'un fichier, un objet de classe ifstream sera créé.
// crée un objet pour écrire dans le fichier ofstream /*nom de l'objet*/; // objet de la classe ofstream
Appelons l'objet fout. Voici ce que nous obtenons :
Ofstream fout;
Pourquoi avons-nous besoin d’un objet ? L'objet doit pouvoir écrire dans un fichier. L'objet a déjà été créé, mais n'est pas associé au fichier dans lequel la chaîne doit être écrite.
Fout.open("cppstudio.txt"); // associe l'objet au fichier
Grâce à l'opération point, nous accédons à la méthode de classe open(), dans laquelle nous indiquons le nom du fichier entre parenthèses. Le fichier spécifié sera créé dans le répertoire courant avec le programme. Si un fichier du même nom existe, le fichier existant sera remplacé par le nouveau. Ainsi, le fichier est ouvert, il ne reste plus qu'à y écrire la ligne souhaitée. Cela se fait comme ceci :
Fout<< "Работа с файлами в С++"; // запись строки в файл
En utilisant l'opération stream en conjonction avec l'objet fout, la chaîne Working with files in C++ est écrite dans un fichier. Puisqu'il n'est plus nécessaire de modifier le contenu du fichier, celui-ci doit être fermé, c'est-à-dire que l'objet doit être séparé du fichier.
Fout.close(); // ferme le fichier
Résultat - un fichier a été créé avec la ligne Working with files in C++.
Les étapes 1 et 2 peuvent être combinées, c'est-à-dire sur une seule ligne, créer un objet et l'associer à un fichier. Cela se fait comme ceci :
Ofstream fout("cppstudio.txt"); // crée un objet de la classe ofstream et l'associe au fichier cppstudio.txt
Combinons tout le code et obtenons le programme suivant.
// file.cpp : Définit le point d'entrée de l'application console. #include "stdafx.h" #include
Reste à vérifier que le programme fonctionne correctement, et pour cela, ouvrez le fichier cppstudio.txt et regardez son contenu, ça devrait être - Travailler avec des fichiers en C++.
- créer un objet de la classe ifstream et l'associer au fichier à partir duquel la lecture sera effectuée ;
- lire le fichier ;
- fermez le fichier.
Le programme montre deux façons de lire à partir d'un fichier, la première utilise l'opération de transfert vers un flux, la seconde utilise la fonction obtenir la ligne() . Dans le premier cas, seul le premier mot est lu, et dans le second cas, une chaîne de 50 caractères est lue. Mais comme il reste moins de 50 caractères dans le fichier, les caractères jusqu'au dernier inclus sont lus. Veuillez noter que lire une deuxième fois (ligne 17) a continué après le premier mot, et non depuis le début, puisque le premier mot a été lu dansligne 14. Le résultat du programme est présenté dans la figure 1.
Travailler avec des fichiers en C++ Pour continuer, appuyez sur n'importe quelle touche. . .
Figure 1 - Utilisation de fichiers en C++
Le programme a fonctionné correctement, mais cela n'arrive pas toujours, même si tout est en ordre avec le code. Par exemple, le nom d'un fichier inexistant a été transmis au programme ou il y a eu une erreur dans le nom. Et alors ? Dans ce cas, il ne se passera rien du tout. Le fichier ne sera pas trouvé, ce qui signifie qu'il ne sera pas possible de le lire. Par conséquent, le compilateur ignorera les lignes où le travail est effectué sur le fichier. En conséquence, le programme se fermera correctement, mais rien ne s'affichera à l'écran. Il semblerait que ce soit une réaction tout à fait normale face à une telle situation. Mais un simple utilisateur ne comprendra pas ce qui se passe et pourquoi la ligne du fichier n'apparaît pas à l'écran. Donc, pour que tout soit très clair, C++ fournit une telle fonction - is_open(), qui renvoie des valeurs entières : 1 - si le fichier a été ouvert avec succès, 0 - si le fichier n'a pas été ouvert. Modifions le programme en ouvrant un fichier, de sorte que si le fichier n'est pas ouvert, un message correspondant s'affiche.
// file_read.cpp : Définit le point d'entrée de l'application console. #include "stdafx.h" #include
Le résultat du programme est présenté dans la figure 2.
Le fichier ne peut pas être ouvert ! Pour continuer, appuyez sur n'importe quelle touche. . .
Figure 2 - Travailler avec des fichiers en C++
Comme le montre la figure 2, le programme a signalé qu'il était impossible d'ouvrir le fichier. Par conséquent, si le programme fonctionne avec des fichiers, il est recommandé d'utiliser cette fonction, is_open(), même si vous êtes sûr que le fichier existe.
Modes d'ouverture de fichiers
Les modes d'ouverture de fichiers déterminent la manière dont les fichiers sont utilisés. Pour définir le mode, la classe ios_base fournit des constantes qui déterminent le mode d'ouverture du fichier (voir Tableau 1).
Les modes d'ouverture de fichiers peuvent être définis directement lors de la création d'un objet ou lors de l'appel de la fonction open() .
Ofstream fout("cppstudio.txt", ios_base::app); // ouvre le fichier pour ajouter des informations à la fin du fichier fout.open("cppstudio.txt", ios_base::app); // ouvre le fichier pour ajouter des informations à la fin du fichier
Les modes d'ouverture de fichiers peuvent être combinés à l'aide d'une opération logique au niveau du bit ou| , par exemple : ios_base::out | ios_base::trunc - ouvre un fichier en écriture après l'avoir effacé.
Les objets de la classe ofstream, lorsqu'ils sont associés à des fichiers, contiennent par défaut des modes d'ouverture de fichiers ios_base::out | ios_base ::trunc . Autrement dit, le fichier sera créé s'il n'existe pas. Si le fichier existe, son contenu sera supprimé et le fichier lui-même sera prêt à être écrit. Les objets de la classe ifstream, lorsqu'ils sont associés à un fichier, ont le mode d'ouverture de fichier par défaut ios_base::in - le fichier est ouvert en lecture seule. Le mode d'ouverture du fichier est également appelé drapeau ; pour des raisons de lisibilité, nous utiliserons ce terme à l'avenir. Le tableau 1 ne répertorie pas tous les indicateurs, mais ceux-ci devraient suffire pour vous aider à démarrer.
Notez que les indicateurs ate et app ont une description très similaire, ils déplacent tous deux le pointeur vers la fin du fichier, mais l'indicateur app permet uniquement d'écrire jusqu'à la fin du fichier, et l'indicateur ate déplace simplement le drapeau vers la fin. du fichier et ne limite pas où écrire.
Développons un programme qui, à l'aide de l'opération sizeof(), calculera les caractéristiques des principaux types de données en C++ et les écrira dans un fichier. Caractéristiques:
- nombre d'octets alloués au type de données
- la valeur maximale qu'un type de données particulier peut stocker.
Le fichier doit être écrit au format suivant :
/* type de données octet valeur maximale bool = 1 255,00 char = 1 255,00 short int = 2 32767,00 unsigned short int = 2 65535,00 int = 4 2147483647,00 unsigned int = 4 4294967295,00 long int = 4 2147483647. 00 non signé long int = 4 4294967295.00 float = 4 2147483647.00 flotteur long = 8 9223372036854775800.00 double = 8 9223372036854775800.00 */
Un tel programme a déjà été développé plus tôt dans la section, mais là, toutes les informations sur les types de données ont été sorties sur le périphérique de sortie standard, et nous devons refaire le programme pour que les informations soient écrites dans un fichier. Pour ce faire, vous devez ouvrir le fichier en mode écriture, avec troncature préalable des informations du fichier actuel ( ligne 14). Une fois le fichier créé et ouvert avec succès (lignes 16 à 20), au lieu de l'instruction cout, dans ligne 22 nous utilisons l'objet fout. ainsi, au lieu de l'écran, les informations sur le type de données seront écrites dans un fichier.
// write_file.cpp : Définit le point d'entrée de l'application console. #include "stdafx.h" #include
Il est impossible de ne pas remarquer que les changements dans le programme sont minimes, et tout cela grâce au fait que les entrées/sorties standard et les entrées/sorties de fichiers sont utilisées exactement de la même manière. A la fin du programme, àligne 45Nous avons explicitement fermé le fichier, bien que cela ne soit pas nécessaire, mais que cela soit considéré comme une bonne pratique de programmation. Il convient de noter que toutes les fonctions et manipulateurs utilisés pour formater les entrées/sorties standard sont également pertinents pour les entrées/sorties de fichiers. Par conséquent, aucune erreur ne s'est produite lorsque l'instruction cout a été remplacé par un objet fout.
Pour faciliter l'accès, les informations contenues dans les périphériques de stockage sont stockées sous forme de fichiers.
Un fichier est une zone nommée de mémoire externe allouée au stockage d'un tableau de données. Les données contenues dans les fichiers sont de nature très diverse : programmes en langage algorithmique ou machine ; données initiales pour le fonctionnement du programme ou les résultats de l'exécution du programme ; textes libres; images graphiques, etc.
Répertoire (dossier, répertoire) - une collection nommée d'octets sur un support de stockage contenant les noms des sous-répertoires et des fichiers, utilisée dans le système de fichiers pour simplifier l'organisation des fichiers.
Système de fichiers appelé la partie fonctionnelle du système d'exploitation qui effectue des opérations sur les fichiers. Des exemples de systèmes de fichiers sont FAT (FAT - File Allocation Table), NTFS, UDF (utilisés 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 disques de petite capacité, FAT32 – pour les lecteurs FLASH de grande capacité (jusqu'à 32 Go).
Examinons la structure du système de fichiers en utilisant FAT32 comme exemple.
Structure du fichier FAT32
Les périphériques de mémoire externes du système FAT32 ont un adressage par bloc plutôt que par octet. Les informations sont écrites sur un périphérique de mémoire externe sous forme de blocs ou de secteurs.
Un secteur est l’unité adressable minimale de stockage d’informations sur des périphériques de stockage externes. Généralement, 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 regroupé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 possédant 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'écriture des fichiers sont numérotés à partir de 2. En règle générale, le cluster n°2 est utilisé par le répertoire racine, et à partir du cluster n°3, le tableau de données est stocké. Les secteurs utilisés pour stocker les informations au-dessus du répertoire racine ne sont pas regroupés.
La taille minimale de fichier requise sur le disque correspond à 1 cluster.
Le secteur de démarrage commence par les informations suivantes :
- EB 58 90 – saut inconditionnel et signature ;
- 4D 53 44 4F 53 35 2E 30 MSDOS5.0 ;
- 00 02 – nombre d'octets dans le secteur (généralement 512) ;
- 1 octet – nombre de secteurs dans le cluster ;
- 2 octets – 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) – nombre de secteurs sur le disque ;
- 0x2С (4 octets) – numéro de cluster du répertoire racine ;
- 0x47 (11 octets) – étiquette de volume ;
- 0x1FE (2 octets) – signature du 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).
La table FAT contient des informations sur l'état de chaque cluster sur le disque. Les 2 octets inférieurs de la table FAT stockent F8 FF FF 0F FF FF FF FF (ce qui correspond à l'état des clusters 0 et 1, physiquement absents). Ensuite, l'état de chaque cluster contient le numéro du cluster dans lequel se poursuit le fichier en cours ou les informations suivantes :
- 00 00 00 00 – le cluster est gratuit ;
- FF FF FF 0F – fin du fichier en cours.
- 8 octets – nom du fichier ;
- 3 octets – extension de fichier ;
Le répertoire racine contient un ensemble d'enregistrements d'informations 32 bits sur chaque fichier, contenant les informations suivantes :
Lorsque vous travaillez avec des noms de fichiers longs (y compris les noms russes), le nom du fichier est codé à l'aide du système de codage UTF-16. Dans ce cas, 2 octets sont alloués pour coder chaque caractère. Dans ce cas, le nom du fichier est écrit dans la structure suivante :
- 1 octet de séquence ;
- 10 octets contiennent les 5 caractères inférieurs du nom de fichier ;
- attribut de 1 octet ;
- 1 octet réservé ;
- 1 octet – somme de contrôle du nom DOS ;
- 12 octets contiennent les 3 caractères inférieurs du nom de fichier ;
- 2 octets – numéro du premier cluster ;
- les caractères restants 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 est associé à une structure FILE standard, définie dans stdio.h. La structure FILE contient les informations nécessaires sur le fichier.
L'ouverture d'un fichier se fait à l'aide de la fonction fopen(), qui renvoie un pointeur vers une structure FILE pouvant être utilisée pour des opérations ultérieures sur le fichier.
FICHIER *fopen(nom, type);
nom – nom du fichier à ouvrir (y compris le chemin),
type est un pointeur vers une chaîne de caractères qui définit la manière dont le fichier est accessible :
- "r" - ouvre le fichier en lecture (le fichier doit exister) ;
- "w" - ouvre un fichier vide en écriture ; si le fichier existe, son contenu est perdu ;
- "a" - ouvre le fichier pour l'écrire jusqu'à la fin (pour l'ajouter) ; le fichier est créé s'il n'existe pas ;
- "r+" - ouvre le fichier en lecture et en écriture (le fichier doit exister) ;
- "w+" - ouvre un fichier vide en lecture et en écriture ; si le fichier existe, son contenu est perdu ;
- "a+" - ouvre le fichier pour le lire et l'ajouter ; si le fichier n'existe pas, 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 à l'aide de la fonction fopen(). Le flux à fermer est déterminé par l'argument de la fonction fclose().
Valeur de retour : valeur 0 si le flux a été fermé avec succès ; EOF constant si une erreur survient.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#inclure
int main() (
FICHIER *fp;
nom du caractère = "mon.txt" ;
if ((fp = fopen(name, "r" )) == NULL )
{
printf( "Échec de l'ouverture du fichier");
getchar();
renvoie 0 ;
}
// réussi à ouvrir le fichier
... // actions requises sur les données
fclose(fp);
getchar();
renvoie 0 ;
}
Lire un caractère à partir d'un fichier:
char fgetc(flux);
L'argument de la fonction est un pointeur vers un flux de type FILE. La fonction renvoie le code du caractère lu. Si la fin du fichier est atteinte ou qu'une erreur se produit, la constante EOF est renvoyée.
Écrire un symbole dans un fichier:
fputc(char, flux);
Les arguments de la fonction sont un caractère et un pointeur vers un flux de type FILE. La fonction renvoie le code du caractère lu.
Les fonctions fscanf() et fprintf() sont similaires aux fonctions scanf() et printf(), mais fonctionnent avec des fichiers de données et ont un pointeur de fichier comme premier argument.
fscanf(flux, "InputFormat", arguments);
– comparaison pour identifier l’égalité ou l’inégalité.
Le but pratique d'une énumération est de définir un ensemble de constantes symboliques distinctes d'un type entier.
Un exemple d'utilisation de variables énumérées :
mo=1, tu, we, th, fr, sa, di ) jours ;
puts(“ Entrez le jour de la semaine (de 1 à 7) : ”); scanf("%d", &t_day);
w_day = su; début = mois ;
fin = w_day -t_day ;
printf("\nLundi est le %d jour de la semaine, \maintenant est le %d jour.\n\
Jusqu'à la fin de la semaine %d jours (jours). », début, t_day, fin);
Résultat du programme : Saisir le jour de la semaine (de 1 à 7) : 2
Lundi est le 1er jour de la semaine, maintenant c'est le 2ème jour. Il reste 5 jours (jours) jusqu'à la fin de la semaine.
18. Fichiers en langage C
Un fichier est un ensemble de données localisées sur un support externe et considérées comme un tout lors du traitement. Les fichiers contiennent des données destinées au stockage à long terme.
Il existe deux types de fichiers : texte et binaire. Les fichiers texte sont une séquence de caractères ASCII et peuvent être visualisés et modifiés à l'aide de n'importe quel éditeur de texte.
Les fichiers binaires (binaires) sont une séquence de données dont la structure est déterminée par un logiciel.
Le langage C dispose d'un large éventail de fonctions pour travailler avec des fichiers, dont la plupart se trouvent dans les bibliothèques stdio.h et io.h.
18.1. Ouvrir un fichier
Chaque fichier se voit attribuer un nom logique interne, qui est utilisé ultérieurement lors de son accès. Le nom logique (identifiant du fichier) est
pointeur vers le fichier, c'est-à-dire vers une zone mémoire contenant toutes les informations nécessaires sur le fichier. Le format de déclaration d'un pointeur vers un fichier est le suivant :
FILE * pointeur vers le fichier ; |
|
FILE – identifiant du type de structure décrit dans la bibliothèque standard |
|
stdio.h et contenant les informations suivantes : |
|
tapez structure( | |
– le nombre d'octets non lus restant dans la mémoire tampon ; |
|
la taille habituelle du tampon est de 512 octets ; dès que niveau=0, |
|
le bloc de données suivant est lu dans le tampon à partir du fichier ; |
|
– indicateur d'état du fichier – lecture, écriture, ajout ; |
|
– descripteur de fichier, c'est-à-dire numéro définissant son no- |
|
conservation de caractères non signés ; | – caractère non transmis, c'est-à-dire caractère ungetc ; |
– taille du tampon intermédiaire interne; |
|
tampon de caractères non signé ; | – valeur du pointeur pour l'accès à l'intérieur du tampon, c'est-à-dire |
spécifie le début du tampon, le début de la ligne ou la valeur actuelle |
|
La valeur du pointeur à l'intérieur du tampon en fonction du mode |
|
ma mise en mémoire tampon ; |
|
caractère non signé *curp; | – valeur actuelle du pointeur d’accès à l’intérieur du |
fera, c'est-à-dire spécifie la position actuelle dans le tampon d'échange |
|
continuez avec le programme ; |
|
istemp non signé ; | – indicateur de fichier temporaire ; |
– indicateur lorsque vous travaillez avec un fichier ; |
|
) DÉPOSER; | |
Avant de commencer à travailler avec le fichier, c'est-à-dire Pour pouvoir lire ou écrire des informations dans un fichier, celui-ci doit être ouvert pour y accéder. À cette fin, la fonction est généralement utilisée
FILE* fopen(char* nom_fichier, char* mode);
il prend une représentation externe - le nom physique d'un fichier sur un support (disquette, disque dur) et lui fait correspondre un nom logique.
Nom physique, c'est-à-dire le nom du fichier et son chemin d'accès sont spécifiés par le premier paramètre
– une ligne, par exemple, « a:Mas_dat.dat » – un fichier nommé Mas_dat.dat situé sur une disquette, « d:\\work\\Sved.txt » – un fichier nommé Sved.txt situé sur le disque dur conduire dans le répertoire de travail.
Attention! La barre oblique inverse (\), en tant que caractère spécial, est écrite deux fois sur une ligne.
Lors d'une ouverture réussie, la fonction fopen renvoie un pointeur vers le fichier (ci-après dénommé le pointeur de fichier). En cas d'erreur, NULL est renvoyé. Cette situation se produit généralement lorsque le chemin d'accès au fichier à ouvrir est mal spécifié. Par exemple, si dans la classe d'affichage de notre université vous spécifiez un chemin interdit à l'écriture (généralement d:\work\ est autorisé).
Le deuxième paramètre est une ligne qui spécifie le mode d'accès au fichier :
w – le fichier est ouvert en écriture ; s'il n'existe aucun fichier portant le nom donné, il sera créé ; si un tel fichier existe, alors les informations précédentes sont détruites avant ouverture ;
r – le fichier s'ouvre en lecture seule ; s'il n'existe pas de fichier de ce type, une erreur se produit ;
a – le fichier est ouvert pour ajouter de nouvelles informations à la fin ;
r+ – le fichier est ouvert pour éditer les données – l'écriture et la lecture des informations sont possibles ;
w+ – le même que pour r+ ;
a+ – la même chose que pour a, seule l'écriture peut être effectuée n'importe où dans le fichier ; la lecture de fichiers est également disponible ;
t – le fichier s’ouvre en mode texte ; b – le fichier s’ouvre en mode binaire.
Le mode texte diffère du mode binaire en ce sens que lorsqu'un fichier est ouvert sous forme de texte, la paire de caractères « saut de ligne », « retour chariot » est remplacée par un seul caractère : « saut de ligne » pour toutes les fonctions d'écriture de données dans le fichier. , et pour toutes les fonctions de sortie le caractère "saut de ligne" " est désormais remplacé par deux caractères : "saut de ligne", "retour chariot".
Par défaut, le fichier s'ouvre en mode texte. Exemple : FICHIER *f; – un pointeur vers le fichier f est déclaré ;
f = fopen("d:\\work\\Dat_sp.cpp", "w"); – un fichier de nom logique f, qui porte le nom physique Dat_sp.cpp, situé sur le lecteur d, dans le répertoire de travail, est ouvert en écriture ; ou plus brièvement
FICHIER *f = fopen("d:\\work\\Dat_sp.cpp", "w");
18.2. Fermer un dossier
Après avoir travaillé avec un fichier, l'accès à celui-ci doit être fermé. Ceci est fait par la fonction int fclose (pointeur de fichier). Par exemple, d'après l'exemple précédent, le fichier est fermé comme ceci : fclose (f);
Pour fermer plusieurs fichiers, une fonction est introduite, déclarée comme suit : void fcloseall (void) ;
Si vous devez modifier le mode d'accès à un fichier, vous devez d'abord fermer le fichier puis l'ouvrir à nouveau, mais avec des droits d'accès différents. Pour ce faire, utilisez la fonction standard :
FILE* freopen (char*file_name, char *mode, FILE *file_pointer);
Cette fonction ferme d'abord le fichier déclaré pointeur_fichier(comme le fait la fonction fopen), puis ouvre le fichier avec le nom de fichier et les autorisations "mode".
Le langage C a la capacité de travailler avec des fichiers temporaires qui ne sont nécessaires que pendant l'exécution du programme. Dans ce cas, la fonction est utilisée
FILE* fichier tmp (vide);
qui crée un fichier temporaire sur le disque avec les droits d'accès « w+b » ; une fois le programme terminé ou après la fermeture du fichier temporaire, il est automatiquement supprimé.
18.3. Écrire – lire des informations
Toutes les actions de lecture et d'écriture de données dans un fichier peuvent être divisées en trois groupes : les opérations d'entrée-sortie caractère par caractère ; opérations d'E/S ligne par ligne ; bloquer les opérations d’E/S.
Regardons les principales fonctions utilisées dans chacun de ces trois groupes d'opérations.
E/S caractère par caractère
Dans les fonctions d'E/S caractère par caractère, un caractère est reçu d'un fichier ou un caractère est envoyé à un fichier :
E/S de ligne
Transfert des fonctions E/S ligne depuis un fichier ou vers
Bloquer les E/S
Les fonctions d'E/S de bloc fonctionnent sur des blocs entiers
information: | |
int fread (void*p, intsize, | – lit n blocs de taille en octets chacun dans le fichier |
int n, FICHIER *f) | la f vers une zone mémoire avec le pointeur p (obligatoire |
int fwrite (void*p, intsize, | allouer de la mémoire à l'avance pour le bloc à lire); |
– écrit n blocs de taille octets chacun à partir du |
|
int n, FICHIER *f) | zone mémoire avec pointeur p vers le fichier f. |
Les E/S formatées sont produites par des fonctions.