Opérations sur les fichiers basées sur C (FILE*, fstream, windowsAPI)

Opérations sur les fichiers basées sur C

En ANSI C, il existe deux manières d'exploiter les fichiers, à savoir les opérations sur les fichiers en streaming et les opérations sur les fichiers d'E/S, qui sont présentées ci-dessous.

1. Opération de fichier en streaming

Cette méthode d'opération de fichier a une structure importante FILE est définie dans le fichier d'en-tête stdio.h comme suit :

typedef struct {int level;unsigned flags;char fd;unsigned char hold;int bsize;unsigned char _FAR *buffer;unsigned char _FAR *curp;unsigned istemp;short token;
} FILE;

FILE Cette structure contient les attributs de base des opérations sur les fichiers. Les opérations sur les fichiers doivent être effectuées via les pointeurs de cette structure. Les fonctions couramment utilisées pour de telles opérations sur les fichiers sont présentées dans le tableau ci-dessous. Fonctions
fopen() Ouvrir le flux
. fclose () Fermer le flux
fputc() Écrire un caractère dans le flux
fgetc() Lire un caractère du flux
fseek() Localiser le caractère spécifié dans le flux
fputs() Écrire une chaîne de caractères à diffuser
fgets() Lire une ligne ou des caractères spécifiés dans le flux
fprintf() Sortie vers le flux au format
fscanf() Lire à partir du flux au format
feof() Atteindre le fichier Renvoyer la vraie valeur à la fin
ferror() Renvoyer sa valeur lorsqu'une erreur se produit
rewind() Réinitialiser le localisateur de fichier au début du fichier
remove() Supprimer le fichier
fread() Lit le fichier spécifié à partir du nombre de caractères du flux
fwrite() écrit le nombre de caractères spécifié dans le flux
tmpfile() génère un flux de fichier temporaire
tmpnam() génère un nom de fichier unique

Ce qui suit présente ces fonctions

1.fopen()
Le prototype de fopen est : FILE *fopen(const char *filename, const char *mode), fopen en implémente trois fonctions

as Utiliser pour ouvrir un flux
Connecter un fichier à ce flux
Renvoie un pointeur FILR vers ce flux
Le paramètre filename pointe vers le nom du fichier à ouvrir, et mode représente une chaîne de statut ouvert. Sa valeur est la suivante Table

String signifiant
r ouvre un fichier en lecture seule, le fichier doit exister.
r+ ouvre un fichier lisible et inscriptible. Le fichier doit exister.
rb+ ouvre un fichier binaire en lecture et en écriture, permettant uniquement la lecture et l'écriture de données.
　rt+ read and write ouvre un fichier texte, permettant la lecture et l'écriture.
　w Ouvrez un fichier en écriture seule. Si le fichier existe, la longueur du fichier sera effacée à 0, c'est-à-dire que le contenu du fichier disparaîtra. Si le fichier n'existe pas, créez le fichier.
　w+ ouvre un fichier lisible et inscriptible. Si le fichier existe, la longueur du fichier sera remise à zéro, c'est-à-dire que le contenu du fichier disparaîtra. Si le fichier n'existe pas, créez le fichier.
a Ouvrez un fichier en écriture seule en mode ajout. Si le fichier n'existe pas, le fichier sera créé. Si le fichier existe, les données écrites seront ajoutées à la fin du fichier, c'est-à-dire que le contenu original du fichier sera conservé. (Les caractères EOF sont réservés)
　a+ ouvre un fichier lisible et inscriptible en mode ajout. Si le fichier n'existe pas, le fichier sera créé. Si le fichier existe, les données écrites seront ajoutées à la fin du fichier, c'est-à-dire que le contenu original du fichier sera conservé. (Le caractère EOF d'origine n'est pas conservé)
wb Ouvrir ou créer un nouveau fichier binaire en écriture uniquement ; seule l'écriture de données est autorisée ;
wb+ lire et écrire Ouvrir ou créer un fichier binaire, permettant la lecture et l'écriture.
wt+ Lire et écrire Ouvrir ou créer un fichier texte ; permet la lecture et l'écriture.
AT+ lit et écrit pour ouvrir un fichier texte, permettant de lire ou d'ajouter des données à la fin du texte.
Ab+ ouvre un fichier binaire en lecture et en écriture, permettant de lire ou d'ajouter des données à la fin du fichier.

Un fichier peut être ouvert en mode texte ou en mode binaire. La différence entre les deux est la suivante : en mode texte, le retour chariot est considéré comme un caractère 'n', tandis qu'en mode binaire, il est considéré comme deux. caractères 0x0D, 0x0A ; Si 0x1B est lu dans le fichier, le mode texte pensera que c'est la fin du fichier, c'est-à-dire que le modèle binaire ne traitera pas le fichier et le mode texte convertira les données en conséquence dans un certain temps. chemin.

Le système s'ouvre par défaut en mode texte. Vous pouvez modifier la valeur de toutes les variables _fmode pour modifier ce paramètre. Par exemple, _fmode=O_TEXT ; définit le mode d'ouverture par défaut en mode texte ; puis définissez le mode d'ouverture par défaut sur le mode binaire.

Cette fonction renvoie un pointeur FILE, il n'est donc pas nécessaire de l'initialiser après avoir déclaré un pointeur FILE. Au lieu de cela, fopen() est utilisé pour renvoyer un pointeur et le connecter à un fichier spécifique s'il réussit ou. échoue, NULL est renvoyé.

Exemple :

FILE *fp;
if(fp=fopen("123.456","wb"))
puts("Fichier ouvert avec succès"); >else
puts("Succès ou échec de l'ouverture du fichier");

2.fclose()

La fonction de fclose() est de fermer le fichier ouvert avec fopen() Son prototype. est : int fclose( FILE *fp); En cas de succès, renvoie 0, échoue à renvoyer EOF.

N'oubliez pas de fermer le fichier ouvert à la fin du programme, sinon les données risquent d'être perdues. J'ai souvent commis cette erreur auparavant.

Exemple : fclose(fp);

3.fputc()

Écrivez un caractère dans le flux, le prototype est int fputc(int c, FILE *stream); caractère avec succès, renvoie EOF en cas d'échec.

Exemple : fputc('X',fp);

4.fgetc()

Lire un caractère du flux, le prototype est int fputc(FILE *stream); avec succès Ce caractère renvoie EOF en cas d'échec.

Exemple : char ch1=fgetc(fp);

1. fseek()

   Cette fonction est généralement utilisée dans les fichiers ouverts en mode binaire. Locate La position spécifiée dans le flux, le prototype est int fseek(FILE *stream, long offset, int whence); s'il renvoie 0 avec succès, le paramètre offset est le nombre de caractères déplacés, d'où est la base du mouvement, et le la valeur est
   

Position de référence de la valeur constante symbolique
SEEK_SET 0 Début du fichier
SEEK_CUR 1 Position actuelle de lecture et d'écriture
SEEK_END 2 Fin du fichier

Exemple : fseek (fp, 1234L,SEEK_CUR);//Déplacer la position de lecture et d'écriture vers l'arrière de 1234 octets par rapport à la position actuelle (le suffixe L indique un entier long)

fseek(fp,0L,2);//Déplacer le position de lecture et d'écriture à la fin du fichier

6.fputs()
Écrire une chaîne dans le flux, prototype int fputs(const char *s, FILE *stream);

Exemple : fputs("I Love You",fp);

7.fgets()
Lire une ligne ou spécifier des caractères du flux Le prototype est char *fgets(char *s, int n, FILE *stream); from Lire n-1 caractères du flux. Sauf si une ligne est lue, le paramètre s est utilisé pour recevoir la chaîne. En cas de succès, le pointeur de s est renvoyé, sinon NULL est renvoyé.

Exemple : Si le texte de la position actuelle d'un fichier est le suivant

Amour, j'ai

Mais……..

Si vous utilisez

fgets(str1,4,file1);

Après exécution str1="Lov", 4-1=3 caractères sont lus, et si vous utilisez

fgets( str1, 23,file1);

puis exécutez str="Love, I Have" et lisez une ligne (en excluant le 'n' à la fin de la ligne).

8.fprintf()
Entrée dans le flux selon le format, son prototype est int fprintf(FILE *stream, const char *format[, argument, …]); comme printf(), Mais au lieu d'écrire sur la console, il écrit dans le flux

Exemple : fprintf(fp,”-%s”,4,”Hahaha”);

9 .fscanf()
Lire à partir du flux au format, son prototype est int fscanf(FILE *stream, const char *format[, address, …]); son utilisation est la même que scanf(), mais au lieu de lire depuis la console, il suffit de lire le flux.

Exemple : fscanf(fp,"%d%d",&x,&y);

10.feof()
Vérifiez si la fin du fichier a été atteinte, et renvoie true si c'est le cas, sinon renvoie 0, son prototype est int feof(FILE *stream);

Exemple : if(feof(fp))printf("La fin du fichier a été atteinte");

11.ferror()
Le prototype est int ferror(FILE *stream); renvoie le dernier code d'erreur du flux, qui peut être effacé par clearerr(). void clearerr(FILE *stream);

Exemple : printf(“%d”,ferror(fp));

12.rewind()
Renvoie la position actuelle de lecture et d'écriture au début du fichier. Le prototype est void rewind(FILE *stream); En fait, this La fonction est équivalente à fseek(fp,0L,SEEK_SET);

Exemple : rewind(fp);

13.remove()
Supprimez le fichier, le prototype est int remove(const char * filename); Le paramètre est le nom du fichier à supprimer, et 0 est renvoyé en cas de succès.

Exemple : remove("c:io.sys");

14.fread()
Lire le nombre spécifié de caractères du flux. Le prototype est size_t fread(void. ptr, size_t size, size_t n, FILE *stream); Le paramètre ptr sert à sauvegarder les données lues. Le pointeur de void peut être remplacé par n'importe quel type de pointeur, tel que char*, int *, etc. ; la taille est le nombre d'octets par bloc ; n est le nombre de blocs lus. En cas de succès, renvoie le nombre réel de blocs lus (et non le nombre d'octets). Cette fonction est généralement utilisée dans les fichiers ouverts en mode binaire.

Exemple :

char x[4230];
FILE *file1=fopen(“c:msdos.sys”,”r”);

fread( x,200,12 ,file1);//Lire un total de 200*12=2400 octets

15.fwrite()
correspond à fread, écrit les données spécifiées dans le flux, le prototype est size_t fwrite(const void ptr, size_t size, size_t n, FILE *stream); Le paramètre ptr est le pointeur de données à écrire. Le pointeur de void peut être remplacé par n'importe quel type de pointeur, tel que. char*, int * et ainsi de suite ; la taille est le nombre d'octets de chaque bloc ; n est le nombre de blocs à écrire. En cas de succès, renvoie le nombre réel de blocs écrits (et non le nombre d'octets). La fonction est généralement utilisée pour les fichiers ouverts en mode binaire.

Exemple :

char x[]=”Je t'aime”
fwire(x, 6,12,fp);//Write 6*12=72 bytes

Écrira "I Love" dans le flux fp 12 fois, un total de 72 octets

16.tmpfile()

Le prototype est FILE *tmpfile(void) ; , ouvert en mode "w+b", et renvoie le pointeur de ce flux temporaire, ou NULL en cas d'échec. A la fin du programme, ce fichier sera automatiquement supprimé.

Exemple : FILE *fp=tmpfile();

17.tmpnam();

Le prototype est char *tmpnam(char *s); en fait, tmpfile() appelle cette fonction. Le paramètre s est utilisé pour enregistrer le nom de fichier obtenu et renvoyer ce pointeur. En cas d'échec, NULL est renvoyé.

Exemple : tmpnam(str1);

2. Opération de fichier d'E/S directe

Il s'agit d'une autre opération de fichier fournie par C, qui s'effectue via le stockage direct/récupère le fichier pour terminer le traitement du fichier, et l'opération de fichier de streaming mentionnée dans l'article précédent est effectuée via le tampon ; l'opération de fichier de streaming est effectuée autour d'un pointeur FILE, et ce type d'opération de fichier est effectué autour du "handle" d'un fichier. Allons-y, qu'est-ce qu'une poignée ? Il s'agit d'un nombre entier et d'un jeton unique utilisé par le système pour identifier un fichier (sous WINDOWS, la notion de handle est étendue à l'identification de toutes les ressources de l'appareil). Les fonctions couramment utilisées pour de telles opérations sur les fichiers sont les suivantes. Ces fonctions et certains des symboles utilisés sont définis dans io.h et fcntl.h. Lors de leur utilisation, les fichiers d'en-tête correspondants doivent être ajoutés.

Description de la fonction

open() ouvre un fichier et renvoie son handle
close() ferme un handle
lseek() localise l'emplacement spécifié du fichier
bloc read() Lire le fichier
write() Écrire le fichier en blocs
eof() Tester si le fichier est terminé
filelength() Obtenir la longueur du fichier
rename() Renommer le fichier
chsize( ) Changer la longueur du fichier

Ces fonctions seront expliquées une par une ci-dessous :

1.open()
Ouvrez un fichier et renvoyez son handle S'il échoue, une valeur inférieure à 0 sera renvoyée. Le prototype est int open(const char *path, int access [, unsigned mode] ); Le paramètre path est le nom du fichier à ouvrir, l'accès est le mode à ouvrir et le mode est facultatif. Indique les attributs du fichier et est principalement utilisé dans les systèmes UNIX. Ce paramètre n'a aucune signification sous DOS/WINDOWS. Les modes d'ouverture de fichiers sont les suivants.

Signification du symbole Signification du symbole Signification du symbole
O_RDONLY Mode lecture seule O_WRONLY Mode écriture seule O_RDWR Mode lecture/écriture
O_NDELAY Utilisé dans les systèmes UNIX O_APPEND Mode ajout O_CREAT Créer le fichier s'il n'existe pas
O_TRUNC Tronque la longueur du fichier à 0. O_EXCL est utilisé avec O_CREAT Si le fichier existe, une erreur O_BINARY est renvoyée
O_TEXT Mode texte

Pour plusieurs exigences, vous pouvez utiliser. l'opérateur "|" pour se connecter, tel que O_APPEND|O_TEXT Indique l'ouverture du fichier en mode texte et en mode ajout.

Exemple : int handle=open("c:msdos.sys",O_BINARY|O_CREAT|O_WRITE)

2.close()
Fermez un handle, le prototype est int close ( int handle); en cas de succès, return 0

Exemple : close(handle)

3.lseek()
Localisez à la position spécifiée, le prototype est : long lseek(int handle, long offset, int fromwhere); Le paramètre offset est la quantité de mouvement, fromwhere est la position de référence du mouvement, la valeur est la même que celle de fseek() mentionnée précédemment, SEEK_SET : le début du fichier ; position actuelle du fichier SEEK_END : ​​la fin du fichier. Cette fonction renvoie le nouvel emplacement d'accès du fichier après exécution.

Exemple :

lseek(handle,-1234L,SEEK_CUR);//Avance la position d'accès de 1234 octets par rapport à la position actuelle.
x=lseek(hnd1,0L,SEEK_END);//Déplacer la position d'accès à la fin du fichier, x=La position de la fin du fichier est la longueur du fichier

4.read ()
À partir du fichier Lire un bloc, le prototype est int read(int handle, void *buf, unsigned len); le paramètre buf enregistre les données lues, et len ​​est les octets lus. La fonction renvoie les octets réellement lus.

Exemple : char x[200];read(hnd1,x,200);

5.write()
Écrivez une donnée dans le fichier, le prototype est un entier write(int handle, void *buf, unsigned len); La signification des paramètres est la même que read(), et les octets réellement écrits sont renvoyés.

Exemple : char x[]=”I Love You”;write(handle,x,strlen(x));

7.eof()
Similaire à feof() , Teste si le fichier est terminé, renvoie 1, sinon renvoie 0 ; le prototype est : int eof(int handle);

Exemple : while(!eof(handle1)){……};

8.filelength()
Renvoie la longueur du fichier, le prototype est long filelength(int handle); équivalent à lseek(handle,0L,SEEK_END)

Exemple : long x=filelength(handle );

9.rename()
Renommer le fichier, le prototype est int rename(const char *oldname, const char *newname); Le paramètre oldname est l'ancien nom du fichier et newname est le nouveau nom de fichier. Renvoie avec succès 0

Exemple : rename("c:config.sys","c:config.w40");

10.chsize();
Modifier la longueur du fichier, prototype Il s'agit de int chsize (int handle, long size) ; le paramètre size représente la nouvelle longueur du fichier et renvoie 0 en cas de succès, sinon -1 est renvoyé si la longueur spécifiée est inférieure à la longueur du fichier, le fichier sera renvoyé. tronqué ; si la longueur spécifiée est supérieure à la longueur du fichier, ajoutez alors ' à la fin du fichier.

ios::app : ouvre le fichier en mode ajout
ios::ate : une fois le fichier ouvert, il est positionné à la fin du fichier, ios:app contient cet attribut
ios:: binaire : Ouvrir en mode binaire Fichier, le mode par défaut est le mode texte. La différence entre les deux méthodes est montrée dans l'article précédent
ios::in : Le fichier est ouvert en mode saisie (fichier => programme)
ios::out : Le fichier est ouvert en mode sortie (programme => fichier)
ios::nocreate : ne crée pas le fichier, donc l'ouverture échoue lorsque le fichier n'existe pas
ios::noreplace : n'écrase pas le fichier, donc l'ouverture du fichier échoue si le fichier existe
ios::trunc : Si le fichier existe, remplacez le fichier. La longueur est définie sur 0
Vous pouvez utiliser "ou" pour connecter les attributs ci-dessus, tels que ios::out|ios::binary

La valeur d'attribut du fichier ouvert est :

0 : Fichier ordinaire, ouvert pour accès
1 : Fichier en lecture seule
2 : Fichier caché
4 : Fichier système
Vous pouvez utiliser "ou" ou "+" pour connecter les attributs ci-dessus, tels que 3 ou 1 |2 pour ouvrir le fichier avec des attributs en lecture seule et implicites.

Par exemple : ouvrez le fichier c:config.sys en mode entrée binaire

fstream file1
file1.open("c:config.sys",ios::binary| ios: :in,0);

Si la fonction open n'a qu'un seul paramètre, le nom du fichier, elle est ouverte en lecture/écriture de fichiers ordinaires, c'est-à-dire :

file1.open( "c:config.sys" );96b4fef55684b9312718d5de63fb7121file1.open(“c:config.sys”,ios::in|ios::out,0);

De plus, fstream a la même structure que la fonction open(), pour l'exemple ci-dessus, le fichier peut être ouvert lorsqu'il est défini :

fstream file1("c:config.sys");

En particulier , fstream a deux sous-classes : ifstream (flux de fichier d'entrée) et ofstream (flux de fichier de sortie), ifstream ouvre le fichier en mode entrée par défaut (file => programme), et ofstream ouvre le fichier en mode sortie par défaut.

ifstream file2("c:pdos.def");//Ouvre le fichier en mode entrée
ofstream file3("c:x.123");//Ouvre le fichier en mode sortie

Ainsi, dans les applications réelles, choisissez différentes classes à définir en fonction de différents besoins : si vous souhaitez ouvrir en mode entrée, utilisez ifstream pour définir si vous souhaitez ouvrir en mode sortie, utilisez ofstream pour définir if ; vous souhaitez ouvrir en mode sortie, utilisez ofstream pour définir ; Pour ouvrir en mode entrée/sortie, utilisez fstream pour le définir.

2. Fermez le fichier
Le fichier ouvert doit être fermé après utilisation. fstream fournit la fonction membre close() pour terminer cette opération, par exemple : file1.close(). ; Fermez simplement le fichier connecté au fichier1.

3. Lecture et écriture de fichiers
La lecture et l'écriture de fichiers sont divisées en lecture de fichiers texte et de fichiers binaires. La lecture de fichiers texte est relativement simple, en utilisant des insertions et des extracteurs. pour la lecture binaire, c'est plus compliqué. Les deux méthodes suivantes seront présentées en détail

1 Lire et écrire des fichiers texte
Fichier texte La lecture et l'écriture sont très simples : utiliser. l'inséreuse (8574890bfa239e7b28a35221e5fdfd48>) pour saisir à partir du fichier. Supposons que le fichier1 soit ouvert en entrée et que le fichier2 soit ouvert en sortie. Un exemple est le suivant :

file2<<"I Love You";//Écrivez la chaîne "I Love You" dans le fichier
int i; // L'entrée From File est une valeur entière.

Cette méthode a également une capacité de formatage simple, par exemple, vous pouvez spécifier la sortie au format hexadécimal, etc. Les formats spécifiques sont les suivants

Entrée/sortie de la fonction du manipulateur

formats dec Entrée et sortie de données numériques décimales
endl génère un caractère de nouvelle ligne et actualise la sortie de ce flux
ends génère une sortie de caractère nul
formats hexadécimaux Entrée et sortie de données numériques hexadécimales
oct est formaté en entrée de données numériques octales et output
setpxecision(int p) définit le nombre de chiffres de précision pour la sortie en virgule flottante

Par exemple, pour afficher 123 au format hexadécimal : file1<<< ;123;Pour afficher 3.1415926 avec 5 chiffres précision : fichier1<<<3.1415926.

2. Lecture et écriture de fichiers binaires ①put()
la fonction put() écrit un caractère dans le flux, son prototype est ofstream &put(char ch), utiliser C'est également relativement simple, comme file1.put('c'); qui consiste à écrire un caractère 'c' dans le flux.

②get()

La fonction get() est plus flexible et possède 3 formes surchargées couramment utilisées :

L'une est la forme correspondant à put() : ifstream &get(char &ch ) ;La fonction est de lire un caractère du flux, et le résultat est enregistré dans le ch de référence. S'il atteint la fin du fichier, un caractère nul est renvoyé. Par exemple, file2.get(x); signifie lire un caractère du fichier et enregistrer le caractère lu dans x.

Le prototype d'un autre formulaire surchargé est : int get(); Ce formulaire renvoie un caractère du flux Si la fin du fichier est atteinte, EOF est renvoyé, tel que x=file2.get(). ; et La fonction de l'exemple ci-dessus est la même.

Il existe une autre forme de prototype : ifstream &get(char *buf,int num,char delim='n'); cette forme lit les caractères dans le tableau pointé par buf jusqu'à ce que num soit lu en caractères ou en caractères. Le caractère spécifié par delim est rencontré. Si le paramètre delim n'est pas utilisé, le caractère de nouvelle ligne par défaut « n » sera utilisé. Par exemple :

file2.get(str1,127,'A');//Lire les caractères du fichier dans la chaîne str1, se terminer lorsque le caractère 'A' est rencontré ou que 127 caractères sont lus.

③Lire et écrire des blocs de données
Pour lire et écrire des blocs de données binaires, utilisez les fonctions membres read() et write(). Leurs prototypes sont les suivants :

read(unsigned char *buf, int num );
write(const unsigned char *buf,int num);

read() lit num caractères du fichier dans le tampon pointé par buf, si num caractères n'ont pas encore été lus Lorsque la fin du fichier est atteinte, vous pouvez utiliser la fonction membre int gcount(); pour obtenir le nombre réel de caractères lus ; et write() écrit num caractères du cache pointé par buf dans le fichier. notant que le type de cache est unsigned char *, une conversion de type peut parfois être nécessaire.

Exemple :

unsigned char str1[]=”Je t'aime”
int n[5]; >ofstream out("aaa.aaa");
out.write(str1,strlen(str1));//Écrivez toutes les chaînes str1 dans aaa.aaa
in.read((unsigned char* )n, sizeof(n));//Lire l'entier spécifié à partir de xxx.xxx, faites attention à la conversion de type
in.close();out.close();

quatre, détectez EOF

la fonction membre eof() est utilisée pour détecter si la fin du fichier est atteinte. Si la fin du fichier est atteinte, une valeur non nulle est renvoyée, sinon 0 est renvoyé. Le prototype est int eof();
Exemple : if(in.eof())ShowMessage("La fin du fichier a été atteinte !");

5. Positionnement du fichier

et C La différence dans les opérations sur les fichiers est que le système d'E/S C++ gère deux pointeurs associés à un fichier. L'un est le pointeur de lecture, qui indique l'emplacement de l'opération d'entrée dans le fichier ; l'autre est le pointeur d'écriture, qui indique l'emplacement de l'opération d'écriture suivante. Chaque fois qu'une entrée ou une sortie est effectuée, le pointeur correspondant change automatiquement. Par conséquent, le positionnement du fichier C++ est divisé en position de lecture et positionnement en position d'écriture. Les fonctions membres correspondantes sont seekg() et seekp() pour définir la position de lecture et seekp pour définir la position d'écriture. Leurs formes les plus courantes sont les suivantes :

istream &seekg(streamoff offset,seek_dir origin);

ostream &seekp(streamoff offset,seek_dir origin);

streamoff est défini dans iostream.h , Définissez la valeur maximale pouvant être obtenue par offset. seek_dir représente la position de base du mouvement. Il s'agit d'une énumération avec les valeurs suivantes :

ios::beg : Début du fichier

ios::cur. : Position actuelle du fichier

ios::end : Fin du fichier
Ces deux fonctions sont généralement utilisées pour les fichiers binaires, car les fichiers texte peuvent être différents de la valeur attendue en raison de l'interprétation des caractères par le système.

Exemple :

file1.seekg(1234,ios::cur);//Déplacez le pointeur de lecture du fichier vers l'arrière de 1234 octets à partir de la position actuelle

file2.seekp( 1234 ,ios::beg);//Déplacez le pointeur d'écriture du fichier en arrière de 1234 octets depuis le début du fichier

Opération de fichier basée sur WINAPI

---

WINAPI fournit deux Un groupe des fonctions d'exploitation de fichiers est pour la compatibilité avec les programmes 16 bits et est relativement simple. L'autre groupe est spécialement conçu pour les programmes 32 bits et est plus difficile à utiliser. Ci-dessous, je vais lister ces deux groupes de fonctions 1. Introduction : <.>

1. Un ensemble de fonctions compatibles avec les programmes 16 bits

⑴_lopen Prototype : HFILE _lopen(

LPCSTR lpPathName, // nom du fichier

int iReadWrite //Méthode d'accès au fichier
);

Fonction : ouvrez le fichier et renvoyez son handle avec succès. Semblable à ceci, il existe une fonction OpenFile(). Vous pouvez vérifier le fichier d'aide par vous-même. .

Description du paramètre : lpPathName est le nom du fichier à ouvrir, iReadWrite est la méthode d'accès au fichier, il existe trois méthodes principales :

OF_READ : Ouvrir en mode lecture seule

OF_READWRITE : Ouvrir en mode lecture seule Ouvrir en mode écriture

OF_WRITE : Ouvrir en mode écriture seule

Il existe également des attributs tels que OF_SHARE_COMPAT Puisqu'ils ne sont pas couramment utilisés, je ne les présenterai pas un par un ici.

⑵_lclose()
Prototype : HFILE _lclose( HFILE hFile);

Fonction : Fermez le fichier, renvoie 0 avec succès

Description du paramètre : hFile : handle à être fermé

⑶_lread()

Prototype : UINT _lread( HFILE hFile, // Descripteur de fichier

LPVOID lpBuffer, // Tampon pour sauvegarder les données

UINT uBytes // Longueur à lire
);

Fonction : Lire le fichier et renvoyer le nombre réel de caractères lus. De la même manière, il existe une fonction _hread(), vous pouvez vérifier le fichier d'aide par vous-même.

⑷_lwrite()

Prototype : UINT _lwrite( HFILE hFile, // Descripteur de fichier

LPCSTR lpBuffer, // Buffer pour sauvegarder les données

UINT uBytes // Longueur à écrire
);

Fonction : Écrivez un fichier et renvoyez le nombre réel de caractères écrits. De la même manière, il existe également une fonction _hwrite(), vous pouvez vérifier le fichier d'aide par vous-même.

⑸_llseek()

Prototype : LONG _llseek( HFILE hFile, // Poignée de fichier

LONG lOffset, // Quantité de mouvement

int iOrigin // Position de référence du mouvement
) ;

Fonction : Déplacer la position de lecture et d'écriture du fichier, et renvoyer avec succès la position de lecture et d'écriture du fichier après le déplacement

Description du paramètre : La valeur de iOrigin est l'une des trois situations suivantes :

FILE_BEGIN : ​​En-tête du fichier

FILE_CURRENT : Emplacement actuel du fichier

FILE_END : ​​Queue du fichier

⑹_lcreat()
Prototype : HFILE _lcreat( LPCSTR lpPathName, // Le nom du fichier à créer
int iAttribute // Attribut du fichier
);

Fonction : Créer un fichier et renvoyer avec succès son handle

Description du paramètre : L'attribut du fichier est le somme des valeurs suivantes :

0 : Fichier ordinaire

1 : Fichier en lecture seule

2 : Fichier caché

4 : Fichier système
L'utilisation de ces fonctions est similaire à les fonctions de la bibliothèque BCB répertoriées. Il est recommandé d'utiliser les fonctions de la bibliothèque BCB. Veuillez vous référer aux opérations de fichiers précédentes basées sur les fonctions de la bibliothèque BCB.

2. Compatible avec les programmes 32 bits

Créer un fichier
Ouvrir un fichier
Pour lire et écrire des fichiers, vous devez d'abord obtenir un descripteur de fichier, qui peut être obtenue grâce à cette fonction File handle, cette fonction est la porte vers le monde des fichiers.

ReadFile
Lit les informations sur les octets d'un fichier.
Après avoir ouvert le fichier et obtenu le descripteur de fichier, vous pouvez lire les données via cette fonction.

WriteFile
Écrit les informations d'octet dans le fichier.
Vous pouvez également transmettre le handle de fichier à cette fonction pour écrire des données de fichier.

CloseHandle
Ferme le handle de fichier.
Après avoir ouvert la porte, pensez bien sûr à la fermer.

GetFileTime
Obtenir l'heure du fichier.
Trois heures de fichier sont disponibles : l'heure de création, l'heure du dernier accès et l'heure de la dernière écriture.
Cette fonction nécessite également le descripteur de fichier comme paramètre d'entrée.

GetFileSize
Obtenir la taille du fichier.
Étant donné que la taille du fichier peut atteindre plusieurs Go (1G nécessite 30 bits), un type double octet de 32 bits ne peut pas l'exprimer avec précision, donc le code de retour représente les 32 bits inférieurs, et il y a un paramètre de sortie qui peut transmettre les 32 bits élevés.
Cette fonction nécessite également le descripteur de fichier comme paramètre d'entrée.

GetFileAttributes
Obtenir les attributs du fichier.
Vous pouvez obtenir les attributs d'archive, en lecture seule, système, cachés et autres du fichier.
Cette fonction nécessite uniquement un chemin de fichier comme paramètre.

SetFileAttributes
Définissez les attributs du fichier.
S'il peut être obtenu, il devrait naturellement pouvoir être réglé.
Vous pouvez définir les attributs d'archive, de lecture seule, système, caché et autres du fichier.
Cette fonction nécessite uniquement un chemin de fichier comme paramètre.

GetFileInformationByHandle
Obtenir toutes les informations sur le fichier
Cette fonction peut obtenir les informations que toutes les fonctions ci-dessus peuvent obtenir, telles que la taille, les attributs, etc., et inclut également certaines informations qui ne peuvent être obtenues ailleurs. , tels que : fichiers Informations sur l'étiquette, l'index et le lien.
Cette fonction nécessite le descripteur de fichier comme paramètre d'entrée.

GetFullPathName
Obtenir le chemin du fichier Cette fonction obtient le nom de chemin complet du fichier.
Rappelons que le résultat n'est correct que lorsque le fichier est dans le répertoire courant. Si vous voulez connaître le vrai chemin. La fonction GetModuleFileName doit être utilisée.

CopyFile
Copier le fichier
Remarque : seuls les fichiers peuvent être copiés, pas les répertoires

MoveFileEx
Déplacer les fichiers
Vous pouvez déplacer à la fois les fichiers et les répertoires, mais vous ne pouvez pas couvrir les lettres de lecteur. (Définissez l'indicateur de déplacement sous Window2000 pour réaliser une opération de lettre entre lecteurs)

DeleteFile
Supprimer le fichier

GetTempPath
Obtenir le chemin du répertoire temporaire Windows

GetTempFileName
Créez un fichier temporaire unique dans le chemin du répertoire temporaire Windows

SetFilePoint
Déplacez le pointeur du fichier.
Cette fonction est utilisée pour les opérations avancées de lecture et d'écriture sur les fichiers.

Verrouiller et déverrouiller des fichiers

LockFile
UnlockFile
LockFileEx
UnlockFileEx

Les quatre fonctions ci-dessus sont utilisées pour verrouiller et déverrouiller des fichiers. Cela permet un fonctionnement asynchrone des fichiers. Vous pouvez effectuer des opérations distinctes sur différentes parties du fichier en même temps.

Compression et décompression de fichiers

LZOpenFile
Ouvrir un fichier compressé en lecture

LZSeek
Trouver un emplacement dans le fichier compressé

LZRead
Lire un fichier compressé

LZClose
Fermer un fichier compressé

LZCopy
Copiez le fichier compressé et développez-le pendant le traitement

GetExpandedName
Renvoie le nom du fichier du fichier compressé.

Les six fonctions ci-dessus sont des fonctions dans une petite bibliothèque d'extensions dans l'API 32 bits et dans la bibliothèque d'extensions de compression de fichiers. La compression de fichiers peut être créée avec la commande compress.

Imagerie/mapping de fichiers

L'API 32 bits fournit une fonctionnalité appelée imagerie/mapping de fichiers, qui permet de mapper les fichiers directement dans l'espace mémoire virtuel d'une application. Cette technologie peut être utilisée pour. accès simplifié et accéléré aux fichiers.

CreateFileMapping
Créer et nommer le mappage

MapViewOfFile
Charger le fichier de mappage en mémoire

UnmapViewOfFile
Relâchez la vue et réécrivez les modifications dans le file

FlushViewOfFile
Actualisez les modifications d'affichage et écrivez-les sur le disque

Recommandations associées :

C# Write File Operation-Geek Academy C# Video Tutoriel

Exemples C# de création, d'insertion de tableaux, de définition de styles, etc. dans des documents Word

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!