Les exemples que nous avons examinés jusqu'à présent ont démontré une entrée/sortie formatée d'informations dans des fichiers. Il est conseillé d'utiliser l'entrée/sortie de nombres dans des fichiers formatés uniquement lorsqu'ils sont de petite taille et en quantité, ainsi que lorsqu'il est nécessaire de fournir la possibilité de visualiser des fichiers à l'aide de moyens non programmatiques. Sinon, bien sûr, il est beaucoup plus efficace d'utiliser des E/S binaires, qui stockent les nombres de la même manière que dans l'OP de l'ordinateur, plutôt que sous forme de chaînes de caractères. Je vous rappelle qu'une valeur entière (int) ou réelle (float) occupe 4 octets en mémoire, une valeur double prend 8 octets et signification symbolique tapez char- 1 octet. Par exemple, le nombre 12345 dans un fichier texte (formaté) prend 5 octets et dans un fichier binaire, 4 octets.
Fichiers binaires, c'est à dire. fichiers dans lesquels des informations sont stockées formulaire interne les représentations sont utilisées pour une utilisation ultérieure par un logiciel et ne peuvent pas être visualisées sans logiciel. L'avantage des fichiers binaires est que, d'une part, lors de la lecture/écriture, on ne perd pas de temps à convertir les données de la forme symbolique de représentation en forme interne et vice versa, et deuxièmement, il n'y a pas de perte de précision. nombres réels. Tant dans le cas d'entrées/sorties formatées que dans le cas d'entrées/sorties binaires, pour traiter « correctement » les informations d'un fichier, vous devez savoir quels types de données, comment et dans quel ordre sont écrites dans le binaire. fichier, d'autant plus que visualiser un fichier binaire à l'aide d'un éditeur de texte ne fera rien.
Considérons un exemple qui montre l'écriture d'éléments entiers d'un tableau dynamique dans un fichier binaire et leur lecture à partir de ce fichier.
#inclure
#inclure
#inclure
en utilisant l'espace de noms std ;
cout<< "Vvedite kol-vo elementov celochisl. massiva: "; cin >> N ;
int *mas = nouveau int [N];
pour (i=0; je cout<< " Vvedite " << i << "-i element: "; cin >> mas[je]; cout<< "\nIdet zapis dannyh v fail..." << endl; ofstream fout("c:\\os\\bin.dat", ios::binary);//créé sortie flux binaire si(!fout) ( cout<< "\n Oshibka otkrytiya faila!"; getch(); return 1; }
fout.write(reinterpret_cast fout.close();//ferme le flux cout<< "Dannye uspeshno zapisany!" << endl; pour (i=0; je ifstream fin("c:\\os\\bin.dat", ios::binary); //crée un fil de discussion pour lire le fichier si(!fin) ( cout<< "\n Oshibka otkrytiya faila!"; getch(); return 1; } cout<< "Fail sodergit:" << endl; fin.read(reinterpret_cast pour (i=0; je getch(); renvoie 0 ; Dans ce programme, une attention particulière doit être portée à l'utilisation des fonctions write() (méthode de classe ofstream) et read() (méthode de classe ifstream). Ces fonctions considèrent les données en termes d'octets et sont conçues pour transférer un certain nombre d'octets d'un tampon de données vers un fichier et vice-versa. Les paramètres de ces fonctions sont l'adresse du tampon et sa longueur en octets. La fonction write() est conçue pour écrire dans un fichier le nombre d'octets spécifié dans le deuxième paramètre parmi ceux spécifiés dans le premier paramètre. adresses tampon de données, et la fonction read() est conçue pour lire les données d'un fichier. Il convient de noter ici que ces fonctions fonctionnent uniquement avec un tampon de données de type char. À cet égard, dans ce programme, nous avons utilisé l'opérateur réinterpréter_cast<>
qui convertit notre tampon de données de type int (mas) en un tampon de type char. Il est important de se rappeler que le casting à l'aide de l'opérateur réinterpréter_cast ofstream fout(nom de fichier, ios::app | ios::binary); fout.write(reinterpret_cast Il faut maintenant discuter du deuxième paramètre des fonctions considérées. Dans ce programme, comme deuxième paramètre, nous avons utilisé l'expression N*sizeof(int), avec laquelle nous avons calculé le nombre d'octets. Par exemple, si nous avons 5 éléments de tableau entiers, alors le nombre d'octets sera de 20. La fonction sizeof() renvoie le nombre d'octets alloués pour le type de données spécifié en paramètre. Par exemple, sizeof( int) renverra 4. Ainsi, le programme donné dans cet exemple vous permet d'écrire des données sous forme binaire dans le fichier bin.dat et de les lire à partir de ce fichier binaire. De plus, après lecture, ces données sont converties au type int, acquièrent une structure de tableau et toutes les opérations peuvent être effectuées avec. Imaginez maintenant que vous deviez écrire un programme qui vous permet de lire les données du fichier bin.dat, et nous savons seulement que ce fichier contient les éléments d'un tableau d'entiers sous forme binaire. Nombre d'éléments écrits ( N ) nous ne savons pas. Lors de la création d'un programme, nous n'avons pas le droit d'utiliser un tableau constant, c'est-à-dire allouez-lui de la mémoire au stade de la création du programme. Cela conduira à un résultat erroné. Parce qu'une valeur N trop petite entraînera le fait que tous les éléments du tableau ne seront pas comptés, et une valeur N trop grande entraînera le remplissage de cellules supplémentaires avec des valeurs aléatoires. Considérons un exemple de programme qui vous permet de lire les éléments d'un tableau d'entiers à partir d'un fichier binaire en allouant dynamiquement de la mémoire, et de prouver le réalisme des données lues, de calculer leur somme. #inclure #inclure #inclure en utilisant l'espace de noms std ; int N, je, somme = 0, dfb ; //dfb - longueur du fichier en octets ifstream fin("c:\\os\\bin.dat", ios :: binaire); si(!fin) ( cout<< "Oshibka otkrytiya faila!"; getch(); return 1; } fin.seekg(0, ios::end);//définit la position de lecture à la fin du fichier (0 octet à partir de la fin) dfb = fin.tellg();//récupère la valeur de la position de fin de fichier (en octets) N = dfb/4 ;//sachant qu'un entier prend 4 octets, calcule le nombre de nombres int *arr = nouveau int [N];//crée un tableau dynamique fin.seekg(0, ios::beg);//avant de lire les données, déplace la position actuelle au début du fichier fin.read(reinterpret_cast cout<< "Iz faila schitano " << N << " elementov:" << endl; pour (i=0; je pour (i=0; je cout<< "\n Ih summa = " << sum; getch(); renvoie 0 ; Regardons de plus près ce programme, dans lequel nous avons activement utilisé les fonctions seekg() et tellg(), qui sont des méthodes de la classe ifstream. Il convient de noter ici que Tout fichier, lorsqu'il est ouvert, est associé à une position dite de lecture ou d'écriture actuelle.. Lorsqu'un fichier est ouvert en lecture, cette position par défaut est définie au début du fichier. Mais bien souvent, il est nécessaire de contrôler la position manuellement pour pouvoir lire et écrire à partir d'un emplacement arbitraire dans le fichier. Les fonctions seekg() et tellg() vous permettent de définir et de vérifier le pointeur de lecture actuel, tandis que les fonctions seekp() et tellp() font la même chose pour le pointeur d'écriture. La méthode seekg(1_parameter, 2_parameter) déplace la position de lecture actuelle du fichier du nombre d'octets spécifié dans le 1_parameter par rapport à l'emplacement spécifié dans le 2nd_parameter. 2_parameter peut prendre l'une des trois valeurs suivantes : ios::beg – depuis le début du fichier ; ios::cur – à partir de la position actuelle ; ios::end – à partir de la fin du fichier. Ici beg, cur et end sont des constantes définies dans la classe ios, et les symboles :: représentent l'opération d'accès à cette classe. Par exemple, l'opérateur fin.seekg(-10, ios::end); vous permet de définir la position de lecture actuelle d'un fichier à 10 octets avant la fin du fichier. Revenons maintenant à la description du fonctionnement du programme. Étant donné que nous ne connaissons pas le nombre de nombres écrits dans le fichier, nous devons d'abord connaître le nombre de nombres. Pour ce faire, en utilisant fin.seekg(0, ios::end); nous passons à la fin du fichier et, à l'aide de la fonction tellg(), renvoyons la longueur du fichier en octets à la variable dfb. La fonction tellg() renvoie la position actuelle du pointeur en octets. Puisque nous connaissons la longueur d'un entier en octets (4 octets), il est facile de calculer le nombre de nombres écrits dans le fichier, connaissant la longueur du fichier en octets ( N = dfb/4 ;). Après avoir trouvé le nombre de nombres, nous créons un tableau dynamique et passons au début du fichier afin de commencer à lire les données à l'aide de la fonction read(). Une fois le nombre spécifié d'octets de données (dfb) transféré vers le tampon de données (arr), les données ainsi lues acquièrent une structure de tableau et deviennent parfaitement adaptées à toutes les opérations et transformations de code. Dans l'exemple ci-dessus, l'option "la plus longue" est "b" : elle nécessite 23 octets (21 octets pour la chaîne et 2 octets pour l'entier). Les options "n" et "m" nécessitent respectivement 4 et 5 octets (voir tableau). nom, élément de l'éditeur Partie variante Les fichiers binaires stockent les informations sous la forme sous laquelle elles sont présentées dans la mémoire de l'ordinateur et sont donc peu pratiques pour les humains. En regardant un tel fichier, il est impossible de comprendre ce qui y est écrit ; il ne peut pas être créé ou corrigé manuellement - dans certains éditeurs de texte - etc. Cependant, tous ces inconvénients sont compensés par la rapidité de travail avec les données. De plus, les fichiers texte sont classés comme structures à accès séquentiel, tandis que les fichiers binaires sont classés comme structures à accès direct. Cela signifie qu'à tout moment vous pouvez accéder à n'importe qui, pas seulement à l'élément actuel du fichier binaire. Les variables de types de données structurées (sauf chaîne) ne peuvent pas être lues à partir d'un fichier texte. Par exemple, si vous devez saisir des données à partir d'un fichier texte pour remplir le dossier du jouet avec des informations sur les jouets disponibles à la vente (nom du produit, prix du produit et tranche d'âge à laquelle le jouet est destiné) : âge : lot de 0..18 ; (précisé dans le fichier par limites) alors vous devrez écrire le code suivant : c:char; i,j,min,max : entier ; a : gamme de jouets ; commencer assign(f,input); réinitialiser(f); pour i:=1 à 100 faire sinon eof(f) puis avec un[je] fais commencer readln(f,nom,prix,min,max); âge := ; pour j:= min à max, faites age:=age+[j]; Comme vous pouvez le constater, une telle lecture élément par élément est très peu pratique et demande beaucoup de travail. Une issue à cette situation est proposée fichiers saisis- leurs éléments peuvent appartenir à n'importe quel type de données basiques ou structurées. La seule restriction est que tous les éléments doivent être du même type. Cet inconvénient apparent est une condition indispensable pour organiser l'accès direct aux éléments d'un fichier binaire : comme dans le cas des tableaux, si la longueur de chaque composant de la structure est connue avec précision, alors l'adresse de n'importe quel composant peut être calculée à l'aide d'une formule très simple : <начало_структуры> + <номер_компонента>*<длина_компонента> Dans la section var se trouvent des variables de fichier conçues pour fonctionner avec fichiers saisis, sont décrits comme suit : var<файловая_перем>: fichier de<тип_элементов_файла>; Aucune variable de fichier ne peut être spécifiée comme constante. Désormais et jusqu'à la fin de la section, par le mot "fichier" nous entendrons " fichier typé binaire" (bien sûr, sauf indication contraire). Équipe attribuer(f,"<имя_файла>");
sert à établir une connexion entre la variable de fichier f et le nom du fichier pour lequel cette variable se chargera de travailler. Doubler "<имя_файла>" peut contenir le chemin complet du fichier. Si le chemin n'est pas spécifié, le fichier est considéré comme se trouvant dans le même répertoire que le module exécutable du programme. En fonction des actions que votre programme va effectuer lors de l'ouverture du fichier, celui-ci peut être ouvert de deux manières : réinitialiser(f); - ouvrir un fichier pour y lire des informations et en même temps y écrire (si un tel fichier n'existe pas, une tentative de l'ouvrir provoquera une erreur). La même commande est utilisée pour renvoyer un pointeur vers le début du fichier ; réécrire(f); - ouvrir un fichier pour y écrire des informations ; si un tel fichier n'existe pas, il sera créé ; si un fichier du même nom existe déjà, toutes les informations qu'il contenait auparavant disparaîtront. Ferment fichiers saisis procédure close(f) , commune à tous les types de fichiers. La lecture à partir d'un fichier ouvert en lecture s'effectue à l'aide de la commande read(). Entre parenthèses, le nom de la variable du fichier est indiqué en premier, puis la liste d'entrée1) : Vous ne pouvez saisir que des variables du type correspondant à la déclaration d'un fichier, mais ce type de données peut également être structuré. Disons, si l'on revient à l'exemple donné en début de paragraphe ". Fichiers saisis", il deviendra évident que l'utilisation fichier tapé au lieu de texte réduira considérablement le texte du programme : tapez toy = nom de l'enregistrement : chaîne ; prix : réel ; âge : lot de 0..18 ; (défini par des limites) var f : fichier de jouet ; a : gamme de jouets ; commencer attribuer(f,entrée); pour i:=1 à 100 fais sinon eof(f) alors read(f,a[i]); fermer(f); La fonction eof(f:file):boolean, déjà familière, signale quand la fin du fichier est atteinte. Toutes les autres fonctions de "fin de recherche" (eoln(), seekeof() et seekeoln()) inhérentes aux fichiers texte ne peuvent pas être appliquées aux fichiers tapés. Mais il existe des sous-programmes spéciaux qui vous permettent de travailler avec fichiers saisis comme pour les structures à accès direct : 1. La fonction filepos(f:file):longint signalera la position actuelle du pointeur dans filef. Si elle pointe vers la toute fin d'un fichier contenant N éléments, alors cette fonction renverra le résultat N . Cela s'explique facilement : les éléments du fichier sont numérotés à partir de zéro, le dernier élément est donc numéroté N-1. Et numberN appartient donc à un élément « inexistant » – signe de fin de fichier. 2. La fonction filesize(f:file):longint calculera la longueur du fichier f . 3. La procédure seek(f:file,n:longint) déplacera le pointeur dans le fichier f au début de l'enregistrement numéro N . S'il s'avère que n est supérieur à la longueur réelle du fichier, alors le pointeur sera déplacé au-delà de la fin réelle du fichier. 4. La procédure truncate(f:file) coupera la « queue » du fichierf : tous les éléments du courant à la fin du fichier en seront supprimés. En fait, seul le signe "fin de fichier" sera réécrit à l'endroit où pointait le pointeur, et les valeurs physiquement "coupées" resteront à leur place d'origine - elles deviendront simplement "orphelines". Vous pouvez enregistrer les variables dans un fichier ouvert en écriture à l'aide de la commande write(). Comme pour la lecture, la variable de fichier est répertoriée en premier, suivie de la liste de sortie : écrire(f,a,b,c); - écrire dans le fichier f (préalablement ouvert en écriture avec les commandes rewrite (f) ou reset (f) ) les variables a , b , c . Sortie vers fichier tapé Seules les variables correspondant à la description du type de données sont autorisées. Les constantes sans nom et sans type ne peuvent pas être imprimées dans fichier tapé. Fichiers saisis sont considérées comme des structures à accès direct et séquentiel. Cela signifie que l'écriture est possible non seulement à la toute fin du fichier, mais également sur tout autre élément. La valeur écrite remplacera la valeur précédente dans cet élément (l'ancienne valeur sera « écrasée »). Par exemple, si vous devez remplacer le cinquième élément d'un fichier par la valeur stockée dans la variable a, vous écrirez alors l'extrait de programme suivant : chercher(f,5); (le pointeur sera placé au début du 5ème élément) écrire(f,a); (le pointeur sera placé au début du 6ème élément) De nombreuses personnes se demandent souvent comment ouvrir un fichier binaire. Ce document est n'importe quel fichier situé sur un ordinateur personnel. Toutes les données situées sur les ordinateurs et les supports qui y sont associés sont généralement enregistrées en bits. C'est de ce mot que vient le nom. Si vous utilisez un simple fichier texte à titre de comparaison, vous n'aurez aucun problème à le lire. Pour ce faire, il suffit d'avoir un éditeur classique sur votre ordinateur ; même un bloc-notes fera l'affaire. Pour ouvrir un fichier binaire, vous ne pourrez pas utiliser un simple bloc-notes. Et si nous parlons du fait que les informations contenues dans les fichiers texte sont cryptées avec les mêmes bits, alors généralement, lorsqu'ils parlent de lecture de fichiers binaires, ils font référence à des documents exécutables. Instructions pour l'action Tout d'abord, vous devez installer un outil logiciel appelé HexEditor, qui est un simple éditeur de fichiers binaires, sur le disque dur de votre ordinateur personnel. Après l'installation, le programme doit être ouvert en double-cliquant sur l'icône. Cet outil vous permettra de lire un fichier binaire en mode réel. Dans ce cas, vous pouvez modifier les données du fichier, ajouter vos propres informations, etc. Pour travailler dans cet éditeur et modifier un fichier binaire, vous devez avoir au moins quelques connaissances dans ce domaine d'activité. Deuxièmement, vous devez vous familiariser avec sa fenêtre principale, qui ne diffère pas beaucoup de la fenêtre d'un éditeur classique. Les mêmes boutons, le même menu, le même corps de document, les mêmes signets et barres d'état. Vous pouvez ouvrir le fichier qui vous intéresse via l'onglet Fichier ou via un bouton spécial situé sur le programme. Après cela, vous pourrez voir le fichier exécutable, qui apparaîtra sous forme de chiffres et de lettres. Vous ne devez pas confondre les symboles avec lesquels un fichier binaire est représenté et ceux dont dispose un éditeur classique. Dans le cas où une décision est prise de supprimer ou de modifier une partie du document, il faut comprendre qu'une partie de celui-ci disparaîtra ou changera. Troisièmement, en utilisant le programme, vous pouvez essayer de modifier n'importe quelle partie du document. Comme mentionné précédemment, l'outil logiciel affiche le fichier d'une manière qui améliore la façon dont vous pouvez trouver la partie du document dont vous avez besoin. De plus, le programme est assez flexible dans sa configuration. Avec son aide, vous pouvez modifier l'affichage graphique du code binaire contenant un fichier binaire. Si des données incorrectes sont saisies dans une partie du fichier, celui-ci peut par la suite cesser de fonctionner complètement ou commencer à fonctionner de manière incorrecte. Dans tous les cas, la saisie de ces données entraînera des modifications à la fois dans le système d'exploitation et directement dans l'ordinateur personnel lui-même. Quatrièmement, après avoir modifié, supprimé ou ajouté certaines données dans un fichier, vous devez enregistrer le résultat de votre travail. Si vous n'avez pas suffisamment d'expérience dans l'édition de fichiers, vous devez vous préparer à des conséquences pas tout à fait agréables. Par exemple, un document peut cesser de fonctionner après des modifications de données. Jusqu'à ce que vous commenciez à bien comprendre ce problème, de nombreuses copies de fichiers seront endommagées. Si vous n'avez pas confiance en vos capacités, vous ne devez pas modifier les données vous-même, en particulier dans les situations où le fichier binaire su doit être corrigé.
Fichiers binaires
Fichiers saisis
Description des fichiers saisis
Objectif d'un fichier tapé
Ouvrir et fermer un fichier saisi
Lecture à partir d'un fichier tapé
Rechercher dans un fichier saisi
Écrire dans un fichier typé
