C travaillant avec des fichiers, créez un fichier. Exemples d'écriture et de lecture à partir d'un fichier. Classe fstream : accès aléatoire aux fichiers

Travailler avec des fichiers texte en C++.

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

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

Créez un nouveau fichier et ajoutez-le à l'espace de travail

Si l'utilisateur a soumis le formulaire avec ce qui suit. Chacun de ces types de fichiers peut également être ajouté à l'espace de travail. Il fonctionne généralement de la même manière que les fichiers sources classiques, mais prend en charge protection supplémentaire cryptage.

• Fichiers sources.
• Fichiers d'en-tête.
• Les fichiers d'en-tête portent l'extension .
• Fichiers texte.
• Les fichiers texte peuvent être utilisés pour documenter des notes.
• Il y en a deux type spécial fichiers texte.

Lors de la création d'un nouveau fichier source, vous avez la possibilité d'ajouter le fichier à l'espace de travail actuel.

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

Pour travailler avec des fichiers, spécial types de données, appelé flux. Couler ifstream est utilisé pour travailler avec des fichiers en mode lecture, et de flux en mode enregistrement. Pour travailler avec des fichiers en mode écriture et lecture, un flux est utilisé fstream.

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

Pour enregistrer données dans un fichier texte, vous avez besoin de :

décrire une variable de type ofstream.

afficher les informations dans un fichier.

assurez-vous de fermer le fichier.

Pour en lisant les données d'un fichier texte, vous avez besoin de :

décrire une variable de type ifstream.

ouvrez un fichier à l'aide de la fonction open.

fermez le fichier.

Enregistrer informations dans un fichier texte

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

Une variable F sera créée pour écrire des informations dans le fichier.

Ouvrir un fichier existant sans l'ajouter à l'espace de travail

Les fichiers ajoutés à l'espace de travail apparaissent sous forme d'icônes dans les dossiers de la fenêtre zone de travail. Seuls les fichiers sources ajoutés à l'espace de travail peuvent être compilés. Si vous avez des fonctions codées dans des fichiers source distincts, mais que les fichiers sources font partie du même fichier d'espace de travail, vous pouvez charger et créer le fichier d'espace de travail par programme et appeler les fonctions.

Ajout de fichiers ouverts à l'espace de travail

Spécification des fichiers d'espace de travail en tant que packages. Utilisateur temporaire ou fichiers personnalisés. Chacun des six dossiers prédéfinis contient des fichiers ajoutés à l'espace de travail de diverses manières.

A l'étape suivante, le fichier doit être ouvert en écriture. DANS cas général l'opérateur d'ouverture du flux ressemblera à :

F.open("fichier", mode);

Ici F est une variable décrite comme ofstream,

déposer - nom et prénom fichier sur disque

mode - mode de travail avec le fichier en cours d'ouverture.

Veuillez noter que lorsque vous spécifiez le nom complet du fichier, vous devez utiliser une double barre oblique. Par exemple, le nom complet du fichier noobs.txt situé dans dossier du jeu sur le lecteur D :, vous devrez écrire ceci :

D:\\jeu\\noobs.txt.

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

ios::in - ouvre le fichier en mode lecture de données, ce mode est le mode par défaut pour ifstreams ;

ios::out - ouvre un fichier en mode écriture de données (dans ce cas, les informations sur le fichier existant sont détruites), ce mode est le mode par défaut pour ofstreams ;

ios::app - ouvre le fichier en mode d'écriture des données jusqu'à la fin du fichier ;

ios::ate - passer à la fin d'un fichier déjà ouvert ;

ios::trunc - efface le fichier, cela se produit également en mode ios::out ;

ios::nocreate - n'ouvre pas un fichier s'il n'existe pas ;

ios :: noreplace - ne pas ouvrir fichier existant.

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

Après une ouverture réussie du fichier (dans n'importe quel mode), la variable F stockera vrai, sinon faux. Cela vous permettra de vérifier l'exactitude de l'opération d'ouverture du fichier.

Ouvrir le fichier (comme prenons un exemple fichier D:\\game\\noobs.txt) en mode enregistrement en utilisant l'une des méthodes suivantes :

// d'abord chemin

du flux F ;

F.open("D:\\game\\noobs.txt", ios::out);

//deuxième méthode, le mode ios::out est le mode par défaut

// Pour coulerde flux

du flux F ;

//la troisième méthode combine la description de la variable et le type du flux

// et ouverture du fichier en une seule instruction

ofstream F("D:\\game\\noobs.txt", ios::out);

Après avoir ouvert un fichier en mode écriture, un fichier vide sera créé dans lequel vous pourrez écrire des informations.

Si vous souhaitez ouvrir un fichier existant en mode écriture en premier, vous devez utiliser ios::app comme mode.

Après avoir ouvert un fichier en mode enregistrement, vous pouvez y écrire de la même manière que sur l'écran, uniquement à la place du périphérique de sortie standardcoutvous devez préciser le nom du fichier ouvert.

Par exemple, pour écrire la variable a dans le flux F, l'instruction de sortie ressemblera à :

Pour une sortie séquentielle vers le flux G de variables b, c, d, l'opérateur de sortie deviendra comme ceci :

G<

La fermeture d'un flux se fait à l'aide de l'opérateur :

EXEMPLE:

Créez un fichier texte D:\\game\\noobs.txt et écrivez-y n nombres réels.

#include "stdafx.h"

#inclure

#inclure

#inclure

en utilisant l'espace de noms std ;

int principal()

setlocale(LC_ALL, "RUS");

int je, n;

doubler un;

//décrit un flux pour écrire des données dans un fichier

de flux f;

//ouvre le fichier en mode écriture,

//modeiOS:: dehorsinstallé par défaut

f.open("D:\\game\\noobs.txt", ios::out);

//entre le nombre de nombres réels

cout<<" n="; cin>> n;

//boucle pour saisir des nombres réels

// et les écris dans un fichier

pour (i=0; je

cout<<"a=";

//entre un numéro

cin>>a;

f<

//ferme le flux

f.close();

système("pause");

renvoie 0 ;

_______________________________________________________________

Afin de lire les informations d'un fichier texte, vous devez décrire une variable comme ifstream. Après cela, vous devez ouvrir le fichier pour le lire à l'aide de l'opérateur ouvrir. Si la variable s'appelle F, alors les deux premières instructions ressembleront à ceci :

F.open("D:\\game\\noobs.txt", ios::in);

Après avoir ouvert un fichier en mode lecture, vous pouvez en lire les informations de la même manière qu'à partir du clavier, uniquement au lieu decinspécifiez le nom du flux à partir duquel les données seront lues.

Par exemple, pour lire le flux F dans la variable a, l'instruction d'entrée ressemblerait à ceci :

Deux nombres dans un éditeur de texte sont considérés comme séparés s'il y a au moins un des caractères entre eux : espace, tabulation, fin de ligne. C'est bien si le programmeur sait à l'avance combien et quelles valeurs stocker dans le fichier texte. Cependant, souvent le type de valeurs stockées dans le fichier est simplement connu, mais leur nombre peut varier. Pour résoudre ce problème, vous devez lire les valeurs du fichier une par une et avant chaque lecture, vérifier si la fin du fichier a été atteinte. Il y a une fonction pour ça F. eof().

Ici F est le nom du thread, la fonction renvoie une valeur booléenne : vrai ou faux, selon que la fin du fichier est atteinte. Par conséquent, une boucle pour lire le contenu du fichier entier peut être écrite comme ceci :

//organiser la lecture des valeurs d'un fichier, exécution

//la boucle se brisera lorsque nous arriverons à la fin du fichier,

//dans ce cas, F.eof() retournera true

tandis que (!F.eof())

EXEMPLE:

Le fichier texte D:\\game\\noobs.txt stocke les nombres réels, les affiche à l'écran et calcule leur nombre.

#include "stdafx.h"

#inclure

#inclure

#inclure

#inclure

en utilisant l'espace de noms std ;

int principal()

setlocale(LC_ALL, "RUS");

entier n=0 ;

flotter un;

fstream F ;

//ouvre le fichier en mode lecture

F.open("D:\\game\\noobs.txt");

//si le fichier a été ouvert correctement, alors

//boucle pour lire les valeurs d'un fichier ; l'exécution de la boucle sera interrompue,

//quand on atteint la fin du fichier, dans ce cas F.eof() retournera true.

tandis que (!F.eof())

//lecture de la valeur suivante du flux F dans la variable a

F>>a ;

//afficher la valeur de la variable a à l'écran

cout<

//augmenter le nombre de nombres lus

//ferme le flux

F.close();

//saisir à l'écran le nombre de nombres lus

cout<<"n="<

//si l'ouverture du fichier était incorrecte, alors la sortie

//messages sur l'absence d'un tel fichier

sinon cout<<" Файл не существует"<

système("pause");

renvoie 0 ;

C++. Traitement des fichiers binaires

Lors de l'écriture d'informations dans un fichier binaire, les caractères et les nombres sont écrits sous forme de séquence d'octets.

Pour écrire données dans un fichier binaire, vous avez besoin de :

décrire une variable de fichier de type FAIL * à l'aide de l'opérateur FILE *filename ; Ici, le nom de fichier est le nom de la variable où le pointeur vers le fichier sera stocké.

écrire des informations dans un fichier à l'aide de la fonction fwrite

Pour compter b données provenant d'un fichier binaire, il vous faut :

décrire une variable de type FILE *

ouvrir un fichier en utilisant la fonction fopen

fermer un fichier en utilisant la fonction fclose

Fonctions de base requises pour travailler avec des fichiers binaires.

Pour ouvertures Le fichier est destiné à la fonction fopen.

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

Ici, filename est une chaîne qui stocke le nom complet du fichier en cours d'ouverture, mode est une chaîne qui détermine le mode de travail avec le fichier ; les valeurs suivantes sont possibles :

"rb" - ouvre le fichier binaire en mode lecture ;

« wb » - crée un fichier binaire pour l'enregistrement ; s'il existe, son contenu est effacé ;

"ab" - crée ou ouvre un fichier binaire à ajouter à la fin du fichier ;

« rb+ » - ouvre un fichier binaire existant en mode lecture-écriture ;

« wb+ » - ouvrez le fichier binaire en mode lecture-écriture, le fichier existant est effacé ;

"ab+" - un fichier binaire est ouvert ou créé pour corriger les informations existantes et ajouter de nouvelles informations à la fin du fichier.

La fonction renvoie NULL dans la variable de fichier f si le fichier ne s'ouvre pas. Après ouverture d'un fichier, son 0ème octet est disponible, le pointeur de fichier est 0 dont la valeur, au fur et à mesure de sa lecture ou de son écriture, est décalée du nombre d'octets lus (écrits). La valeur actuelle du pointeur de fichier est le numéro d'octet à partir duquel l'opération de lecture ou d'écriture aura lieu.

Pour clôture le fichier est destiné à la fonction fclose

int fclose(FILE *nom de fichier);

Renvoie 0 si le fichier a été fermé avec succès, NULL sinon.

La fonction de suppression est pour suppression fichiers.

int supprimer (const char *nom de fichier);

Cette fonction supprime un fichier nommé filenema du disque. Le fichier à supprimer doit être fermé. La fonction renvoie une valeur non nulle si le fichier n'a pas pu être supprimé.

Pour renommer fichiers, la fonction renommer est destinée à :

int rename(const char *ancien nom de fichier, const char *nouveau nom de fichier);

Le premier paramètre est l'ancien nom du fichier, le second est le nouveau. Renvoie 0 si le programme se termine avec succès.

En lisantà partir d'un fichier binaire se fait à l'aide de la fonction fread :

fread(void *ptr, taille, n, FILE *nom de fichier);

La fonction fread lit n éléments de taille taille du fichier nom de fichier dans un tableau ptr. La fonction renvoie le nombre d'éléments lus. Après la lecture d'un fichier, son pointeur est décalé de n*size octets.

Enregistrer vers un fichier binaire se fait à l'aide de la fonction fwrite :

fwrite(const void *ptr, taille, n, FILE *nom de fichier);

La fonction fwrite écrit dans le fichier filename à partir d'un tableau ptr de n éléments de taille size. La fonction renvoie le nombre d'éléments écrits. Après avoir écrit les informations dans le fichier, le pointeur est décalé de n*size octets.

Pour contrôle de fin de fichier il existe une fonction feof :

int feof(FILE *nom de fichier);

Il renvoie une valeur non nulle si la fin du fichier est atteinte.

EXEMPLE:

Créez un fichier binaire D:\\game\\noobs.dat et écrivez-y n nombres entiers et n nombres réels.

#include "stdafx.h"

#inclure

en utilisant l'espace de noms std ;

int principal()

setlocale(LC_ALL, "RUS");

int n, je;

doubler un;

//crée un fichier binaire en mode écriture

f=fopen("D:\\game\\noobs.dat", "wb");

// saisir Nombresn

cout<<"n="; cin>>n;

fwrite(&n, sizeof(int), 1, f);

//boucle pour saisir n nombres réels

pour (i=0; je

//entre le prochain nombre réel

cout<<"a=";

cin>>a;

// écriture d'un nombre réel dans un fichier binaire

fwrite(&a, sizeof(double), 1, f);

// fermer déposer

ffermer(f);

système("pause");

renvoie 0 ;

EXEMPLE:

Afficher le contenu du fichier binaire D:\\game\\noobs.dat créé lors de la tâche précédente

#include "stdafx.h"

#inclure

en utilisant l'espace de noms std ;

int principal()

setlocale(LC_ALL, "RUS");

int n, je;

double *a;

FICHIER *f; //décrit la variable du fichier

//ouvre le fichier binaire existant en mode lecture

// lit un entier du fichier dans la variable n

//sortie n à l'écran

cout<<"n="<

// allouer de la mémoire pour un tableau de n nombres

a=nouveau double[n] ;

//lire n nombres réels du fichier dans le tableau a

// affiche le tableau à l'écran

pour (i=0; je

cout<

cout<

// fermer déposer

ffermer(f);

système("pause");

renvoie 0 ;

Fichier binaire- structure de données séquentielle, après ouverture d'un fichier, le premier octet qui y est stocké est disponible. Vous pouvez écrire ou lire les données d'un fichier de manière séquentielle. Disons que vous devez compter le quinzième nombre, puis le premier. En utilisant l'accès séquentiel, cela peut être fait de la manière suivante :

int n, je;

doubler un;

FICHIER *f;

f=fopen("D:\\game\\noobs.dat", "rb");

pour (i=0; je<15; i++)

ffermer(f);

f=fopen("D:\\game\\noobs.dat", "rb");

fread(&a, taillede(double), 1, f);

ffermer(f);

Comme vous pouvez le constater, lire les nombres d’un fichier, puis rouvrir le fichier n’est pas le moyen le plus pratique. Il sera beaucoup plus pratique d'utiliser la fonction fseek pour déplacer le pointeur de fichier vers un octet donné.

int fseek(FILE *nom de fichier, décalage int long, origine int);

La fonction définit le pointeur de position actuel du fichier F conformément aux valeurs d'origine et de décalage. Le paramètre offset est égal au nombre d'octets dont le pointeur de fichier sera décalé par rapport à l'origine spécifiée par le paramètre origin. La valeur du paramètre origin doit être l'une des valeurs de décalage suivantes définies dans l'en-tête stdio.h :

SEEK_SET - depuis le début du fichier ;

SEEK_CUR - à partir de la position actuelle ;

SEEK_END - à partir de la fin du fichier.

La fonction renvoie une valeur nulle si l'opération a réussi, une valeur non nulle si le décalage a échoué.

La fonction fseek implémente en fait un accès direct à n'importe quelle valeur d'un fichier. Il vous suffit de connaître l'emplacement (numéro d'octet) de la valeur dans le fichier. Examinons l'utilisation de l'accès direct dans les fichiers binaires en utilisant le problème suivant comme exemple.

EXEMPLE

Dans le fichier binaire D:\\game\\noobs.dat créé précédemment, échangez les nombres réels les plus grands et les plus petits.

L'algorithme de résolution du problème comprend les étapes suivantes :

lire les réels d'un fichier dans le tableau a.

recherchez dans le tableau a les valeurs maximale (max) et minimale (min) et leurs nombres (imax, imin).

déplacer le pointeur de fichier vers la valeur maximale et écrire min.

déplacer le pointeur de fichier vers la valeur minimale et écrire max.

Vous trouverez ci-dessous le texte du programme pour résoudre le problème avec des commentaires.

#include "stdafx.h"

#inclure

en utilisant l'espace de noms std ;

int principal()

setlocale(LC_ALL, "RUS");

int n, je, imax, imin ;

double *a, max, min ;

FICHIER *f;

//ouvre un fichier en mode lecture-écriture

f=fopen("D:\\game\\noobs.dat", "rb+");

//lire le numéro du fichier dans la variable n

// nombres réels dans le fichier

fread(&n, taillede(int), 1, f);

cout<<"n="<

// alloue de la mémoire pour stocker les nombres réels,

//qui sera stocké dans le tableau a

a=nouveau double[n] ;

//lire du fichier dans un tableau et des nombres réels

fread(a, taillede(double), n, f);

//recherche des éléments maximum et minimum

//dans le tableau a et leurs indices

pour (imax=imin=0, max=min=a, i=1; je

si (a[i]>max)

max=a[je];

si (un[je]

min=a[je];

// mobile aiguille À maximum élément

fseek(f, sizeof(int)+imax*sizeof(double), SEEK_SET);

//écrit le min au lieu du maximum de l'élément de fichier

fwrite(&min, sizeof(double), 1, f);

// mobile aiguille À minimum élément

fseek(f, sizeof(int)+imin*sizeof(double), SEEK_SET);

//enregistre le maximum au lieu de l'élément de fichier minimum

fwrite(&max, sizeof(double), 1, f);

//fermeture du fichier

ffermer(f);

//mémoire libre

supprimer [ ]un;

système("pause");