Travailler avec des fichiers en C, entrée et sortie dans un fichier en C. Travailler avec des fichiers texte Obtenir des informations sur le répertoire

Dans cet article, nous apprendrons comment lire les données des fichiers et écrire des informations dans les fichiers dans les programmes C. Fichiers en C sont utilisés pour sauvegarder le résultat d’un programme C et l’utiliser lors du redémarrage du programme. Par exemple, vous pouvez enregistrer les résultats des calculs et les statistiques du jeu.
Pour travailler avec des fichiers en C, vous devez inclure la bibliothèque stdio.h
#inclure
Travailler avec fichier en C vous devez spécifier un pointeur vers le fichier selon l'exemple
FILE *nom du pointeur de fichier ;
Par exemple
FICHIER *fin;
Spécifie un pointeur fin vers un fichier
Ensuite, vous devez ouvrir le fichier et le lier au pointeur de fichier. Pour ouvrir un fichier en C en lecture, utilisez la commande
Nom du pointeur de fichier = fopen("chemin du fichier", "r");
Par exemple la commande suivante
fin = fopen("C:\\Users\\user\\Desktop\\data.txt", "r");
ouvrira le fichier data.txt, situé sur le bureau le long du chemin C:\\Users\\user\\Desktop Pour connaître le chemin d'accès au fichier, vous pouvez sélectionner le fichier avec la souris, cliquez sur le bouton droit de la souris et sélectionnez les propriétés du fichier. La section Emplacement indiquera le chemin d'accès au fichier. Veuillez noter qu'en C le chemin est indiqué par deux barres obliques.
Après avoir travaillé avec le fichier en C, vous devez le fermer à l'aide de la commande
fclose(nom du pointeur de fichier)

Lire des informations à partir d'un fichier texte en C

Pour pouvoir lire les caractères russes d'un fichier, vous devez configurer le travail avec le cyrillique à l'aide de la commande
setlocale(LC_ALL, "Russe");

Dans ce cas, vous devez inclure #include au début du programme

Opérateur fscanf()

Pour lire un mot de fichier en C La commande fscanf() est utilisée. Cette commande est similaire à la commande de saisie d'informations au clavier, seul le premier paramètre est un pointeur vers le fichier
fscanf(pointeur de fichier,"%format d'entrée de données1% format d'entrée de données2...",&variable1,&variable2...);
Par exemple la commande
fscanf(fin,"%d%d%d",&a,&b,&c);
lit une chaîne de trois variables entières à partir d'un fichier lié à un fin de pointeur de fichier
Regardons un exemple de programme qui lit les informations d'un fichier texte data.txt dans lequel trois colonnes de nombres sont écrites et les écrit dans des tableaux. Chaque colonne d'informations possède son propre tableau. Détails sur.
#inclure
#inclure
principal()
(int un;
int b;
int c;
int je;
// définit un pointeur vers le fichier
FICHIER *fin;
// ouvre le fichier en lecture
fin = fopen("C:\\Users\\user\\Desktop\\data.txt", "r");
// lecture ligne par ligne du fichier
pour (i=0;i<3;i++)
{
// lecture d'une chaîne à partir de trois valeurs de fichier et écriture dans des tableaux
fscanf(fin,"%d%d%d",&a[i],&b[i],&c[i]);
}
// affiche les tableaux à l'écran
pour (i=0;i<3;i++)
{
printf("%d %d %d ",a[i],b[i],c[i]);
}
getch();
// fermeture du fichier
fclose(fin);
}

Lecture ligne par ligne des informations d'un fichier en SI. Fonction fgets ()

L'opérateur fscanf() lit un mot dans un fichier, c'est-à-dire au premier espace rencontré.
Pour lire la ligne entière d'un fichier en C, utilisez la construction
if (NULL != fgets (variable de chaîne, longueur de chaîne, pointeur de fichier))
{
actions lors de la lecture d'une ligne
}
Par exemple, un programme C qui lit deux lignes d'un fichier et les affiche à l'écran
#inclure
#inclure
#inclure
principal()
{
// définit les variables de chaîne
char st1;
char st2;
//définit un pointeur vers le fichier
FICHIER *fin;
// configurer le travail avec l'alphabet cyrillique
setlocale(LC_ALL, "Russe");
// ouvre le fichier en lecture
fin = fopen("C:\\data.txt", "r");
// lit la première ligne du fichier
if (NULL != fgets (st1, 100, fin))
{
// affiche la chaîne à l'écran
printf("%s ",st1);)
// lit la deuxième ligne du fichier
if (NULL != fgets (st2, 100, fin))
{
// affiche la chaîne à l'écran
printf("%s ",st2);)
// ferme le fichier en lecture
fclose(fin);
}

Écrire des informations dans un fichier texte en C

Pour enregistrer des données vers un fichier en C, vous devez ouvrir le fichier en mode enregistrement
Nom du pointeur de fichier= fopen("chemin du fichier", "w");
Pour écrire sur une ligne d'un fichier texte, utilisez la commande fprnitf(), qui est similaire à la commande en C, seul le premier paramètre est un pointeur vers le fichier
fprintf (nom du pointeur de fichier, "% format d'entrée", variables) ;
Par exemple, écrire la valeur de la variable a dans le fichier out.txt
a = 10 ;
fout = fopen("C:\\Users\\user\\Desktop\\out.txt", "w");
fprintf(fout,"%d", a);
Un exemple de programme C qui demande deux nombres et écrit ces deux nombres ainsi que leur somme dans le fichier out.txt

#inclure
#inclure

principal()
(int un;
int b;
int c;
FICHIER *fout;
fout = fopen("C:\\Users\\user\\Desktop\\out.txt", "w");
printf("entrez le premier chiffre");
scanf("%d", &a);
printf("entrez le deuxième numéro");
scanf("%d", &b);
c=a+b;
fprintf(fout,"%d %d %d",a,b,c);
getch();
fclose(fout);
}

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

Travailler avec des fichiers texte

Travailler avec un fichier texte est similaire à travailler avec la console : en utilisant des fonctions d'entrée formatées, nous enregistrons les données dans un fichier, en utilisant des fonctions de sortie formatées, nous lisons les données d'un fichier. Il existe de nombreuses nuances que nous examinerons plus tard. Les principales opérations à effectuer sont

1. Ouvrez le fichier pour pouvoir y accéder. En conséquence, vous pouvez l'ouvrir pour lire, écrire, lire et écrire, réécrire ou écrire jusqu'à la fin du fichier, etc. Lorsque vous ouvrez un fichier, de nombreuses erreurs peuvent également se produire : le fichier peut ne pas exister, il peut s'agir d'un type de fichier incorrect, vous n'êtes peut-être pas autorisé à travailler avec le fichier, etc. Tout cela doit être pris en compte.
2. Travailler directement avec le fichier - écriture et lecture. Ici, nous devons également nous rappeler que nous ne travaillons pas avec de la mémoire vive, mais avec un flux tamponné, qui ajoute ses propres spécificités.
3. Fermez le fichier. Puisque le fichier est une ressource externe au programme, s'il n'est pas fermé, il continuera à rester en mémoire, éventuellement même après la fermeture du programme (par exemple, il ne sera pas possible de supprimer un fichier ouvert ou d'apporter des modifications, etc.). De plus, il est parfois nécessaire non pas de fermer, mais de « rouvrir » un fichier pour, par exemple, changer le mode d'accès.

De plus, il existe un certain nombre de tâches pour lesquelles nous n'avons pas besoin d'accéder au contenu du fichier : renommer, déplacer, copier, etc. Malheureusement, le standard C ne contient pas de description des fonctions répondant à ces besoins. Ils sont bien entendu disponibles pour chacune des implémentations du compilateur. Lire le contenu d'un répertoire (dossier, répertoire), c'est aussi accéder à un fichier, car le dossier lui-même est un fichier avec des métainformations.

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

Pour travailler avec un fichier, vous avez besoin d'un objet FILE. Cet objet stocke l'identifiant du flux de fichiers et les informations nécessaires à sa gestion, notamment un pointeur vers son tampon, un indicateur de position de fichier et des indicateurs d'état.

L'objet FILE est lui-même une structure, mais ses champs ne sont pas accessibles. Le programme portable doit traiter le fichier comme un objet abstrait permettant d'accéder au flux de fichiers.

La création et l'allocation de mémoire pour un objet de type FILE s'effectuent à l'aide de la fonction fopen ou tmpfile (il en existe d'autres, mais nous nous concentrerons uniquement sur celles-ci).

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

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

Par exemple, ouvrons un fichier et écrivons-y Hello World

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

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

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

Options d'accès aux fichiers.

Taper	Description
r	En lisant. Le fichier doit exister.
w	Écrivez un nouveau fichier. Si un fichier du même nom existe déjà, son contenu sera perdu.
un	Écrivez à la fin du fichier. Les opérations de positionnement (fseek, fsetpos, frewind) sont ignorées. Le fichier est créé s'il n'existait pas.
r+	Lecture et mise à jour. Vous pouvez à la fois lire et écrire. Le fichier doit exister.
w+	Enregistrement et mise à jour. Un nouveau fichier est créé. Si un fichier du même nom existe déjà, son contenu sera perdu. Vous pouvez à la fois écrire et lire.
un+	Fin du message et mise à jour. Les opérations de positionnement sont en lecture seule et ignorées pour les écritures. Si le fichier n'existait pas, un nouveau sera créé.

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

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

Au lieu de la fonction fgets, vous pouvez utiliser fscanf, mais vous devez vous rappeler qu'elle ne peut lire la ligne que jusqu'au premier espace.
fscanf(fichier, "%127s", tampon);

De plus, au lieu d'ouvrir et de fermer un fichier, vous pouvez utiliser la fonction freopen, qui « rouvre » le fichier avec de nouveaux droits d'accès.

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

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

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

Erreur lors de l'ouverture du fichier

Si l'appel de la fonction fopen échoue, il renverra NULL. Les erreurs lors du travail avec des fichiers se produisent assez souvent, donc chaque fois que nous ouvrons un fichier, nous devons vérifier le résultat du travail

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

Le problème se pose lorsque plusieurs fichiers sont ouverts en même temps : si l'un d'entre eux ne peut pas être ouvert, alors les autres doivent également être fermés.

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

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

Mise en mémoire tampon des données

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

1) S'il est plein
2) Si le flux est fermé
3) Si nous indiquons explicitement qu'il est nécessaire de vider le tampon (il y a aussi des exceptions ici :)).
4) Également effacé si le programme s'est terminé avec succès. En même temps, tous les dossiers sont fermés. En cas d'erreur d'exécution, cela peut ne pas se produire.

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

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

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

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

Void setbuf(FILE * flux, char * tampon);

qui prend un FILE déjà ouvert et un pointeur vers un nouveau tampon. La taille du nouveau tampon ne doit pas être inférieure à BUFSIZ (par exemple, sur le poste de travail actuel, BUFSIZ est de 512 octets). Si vous transmettez NULL comme tampon, le flux n'est plus tamponné. Vous pouvez également utiliser la fonction

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

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

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

En cas de succès, la fonction renvoie 0.

Exemple : définissons notre propre tampon et voyons comment s'effectue la lecture d'un fichier. Laissez le fichier être court (quelque chose comme Hello, World !), et nous le lisons caractère par caractère

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

On voit que les données sont déjà dans le tampon. La lecture caractère par caractère se fait depuis le buffer.

feof

Fonction int feof(FILE * stream); renvoie vrai si la fin du fichier est atteinte. La fonction est pratique à utiliser lorsque vous devez parcourir l'intégralité du fichier du début à la fin. Soit un fichier avec du contenu textuel text.txt. Nous lisons le fichier caractère par caractère et l'affichons à l'écran.

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

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

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

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

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

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

Exemples

1. Un fichier contient deux nombres : les dimensions du tableau. Remplissons le deuxième fichier avec un tableau de nombres aléatoires.

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

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

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

3. L'utilisateur saisit les données à partir de la console et celles-ci sont écrites dans un fichier jusqu'à ce que la touche Échap soit enfoncée. Consultez le programme et voyez. comment il se comporte si vous entrez en arrière : ce qui est affiché dans le fichier et ce qui est affiché dans la console.

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

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

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

Une autre solution consiste à lire les nombres jusqu’à la fin du fichier.

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

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

Le fichier de traduction ressemble à ceci

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

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

L'algorithme est le suivant : on lit une ligne d'un fichier, on trouve un caractère de tabulation dans la ligne, on remplace le caractère de tabulation par un zéro, on copie un mot russe du tampon, on copie un mot anglais depuis le tampon, on vérifie l'égalité.

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

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

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

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

Ce n'est toujours pas clair ? – écrire des questions dans la boîte aux lettres

Le mécanisme d'E/S développé par , n'est pas conforme au style généralement accepté de programmation orientée objet aujourd'hui. De plus, il utilise fortement des opérations de pointeur qui sont considérées comme potentiellement dangereuses dans les environnements d'exécution de code sécurisés modernes. Une alternative lors du développement d’applications est le mécanisme des classes d’E/S standard fourni par le standard de langage C++.

Ouverture de fichiers

Les classes les plus couramment utilisées sont ifstream pour la lecture, ofstream pour l'écriture et fstream pour la modification de fichiers.

Toutes les classes d'E/S threadées sont indirectement dérivées de l'ancêtre commun iOS, héritant entièrement de ses fonctionnalités. Ainsi, le mode d'ouverture du fichier est spécifié par le membre de données du type d'énumération open_mode, qui est défini comme suit :

Enum open_mode ( app, binaire, in, out, trunc, ate );

Vous trouverez ci-dessous les valeurs possibles des drapeaux et leur objectif.

Par exemple, pour ouvrir un fichier nommé test.txt pour lire des données sous forme binaire, vous écrivez :

fichier ifstream ; file.open("test.txt", ios::in | ios::binary);

L'opérateur logique OU (|) vous permet de créer un mode avec n'importe quelle combinaison d'indicateurs. Ainsi, pour que lors de l'ouverture d'un fichier par entrée, vous n'écrasiez pas accidentellement un fichier existant du même nom, vous devez utiliser le formulaire suivant :

Fichier hors flux ; file.open("test.txt", ios::out | ios::app);

On suppose que le fichier d'en-tête correspondant est inclus dans le projet :

#inclure

Pour vérifier si le fichier a été ouvert avec succès, vous pouvez utiliser la construction

If (!file) ( //Gestion de l'erreur d'ouverture du fichier)

Opérateurs d’inclusion et d’extraction

Remplacé dans les classes de gestion de fichiers opérateur d'inclusion (<<) записывает данные в файловый поток. Как только вы открыли файл для записи, можно записывать в него текстовую строку целиком:

Déposer<< "Это строка текста";

Vous pouvez également écrire une chaîne de texte en plusieurs parties :

Déposer<< "Это " << "строка " << "текста";

L'instruction endl termine la ligne saisie par un retour chariot :

Déposer<< "Это строка текста" << endl;

À l'aide de l'opérateur include, il est facile d'écrire les valeurs de variables ou d'éléments de tableau dans un fichier :

Fichier Ofstream("Temp.txt"); char buff = "Le tableau de texte contient des variables" ; int vx = 100 ; flotteur pi = 3,14159 ; déposer<< buff << endl << vx << endl << pi << endl;

À la suite de l'exécution du code, trois lignes du fichier texte Temp.txt sont formées :

Le tableau de texte contient des variables 100 3.14159

Notez que les valeurs numériques sont écrites dans le fichier sous forme de chaînes de texte plutôt que de valeurs binaires.

Opérateur de récupération(>>) produit l’effet inverse. Il semblerait que pour extraire les caractères du fichier Temp.txt écrit précédemment, vous écririez un code comme celui-ci :

Fichier Ifstream("Temp.txt"); buff de charbon; intvx; flotter pi ; fichier >> buff >> vx >> pi;

Cependant, l'opérateur d'extraction s'arrêtera au premier délimiteur qu'il rencontrera (espace, tabulation ou nouvelle ligne). Ainsi, lors de l'analyse de la phrase « Le tableau de texte contient des variables », seul le mot « Texte » sera écrit dans le tableau buff, l'espace est ignoré et le mot « tableau » deviendra la valeur de la variable vx entière, et le code l’exécution « tournera mal » avec une violation inévitable de la structure des données. Ensuite, en discutant de la classe ifstream, nous montrerons comment organiser correctement la lecture du fichier de l'exemple précédent.

classe ifstream : lecture de fichiers

Comme son nom l'indique, la classe ifstream est conçue pour saisir un flux de fichiers. Les principales méthodes du cours sont listées ci-dessous. La plupart d'entre eux sont hérités de la classe istream et surchargés pour étendre la fonctionnalité parent. Par exemple, la fonction get, selon le paramètre d'appel, peut lire non seulement un seul caractère, mais également un bloc de caractères.

Il est maintenant clair comment l'exemple précédent doit être modifié pour que l'utilisation de l'opérateur d'extraction de données donne le résultat attendu :

Fichier Ifstream("Temp.txt"); buff de charbon; intvx; flotter pi ; fichier.getline(buff, sizeof(buff)); fichier >> vx >> pi :

La méthode getline lira la première ligne du fichier jusqu'à la fin et l'opérateur >> attribuera des valeurs aux variables.

L'exemple suivant montre l'ajout de données à un fichier texte, puis la lecture de l'intégralité du fichier. Une boucle while(1) est utilisée à la place de while(!file2.eof()) pour les raisons évoquées dans .

#inclure #inclure en utilisant l'espace de noms std ; int main() ( fichier ofstream; file.open("test.txt",ios::out|ios::app); if (!file) ( cout<< "File error - can"t open to write data!"; cin.sync(); cin.get(); return 1; } for (int i=0; i<10; i++) file << i << endl; file.close(); ifstream file2; file2.open("test.txt", ios::in); if (!file2) { cout << "File error - can"t open to read data!"; cin.sync(); cin.get(); return 2; } int a,k=0; while (1) { file2 >>une ; if (file2.eof()) break; cout<< a << " "; k++; } cout << endl << "K=" << k << endl; file2.close(); cin.sync(); cin.get(); return 0; }

L'exemple suivant montre une boucle qui lit les lignes du fichier test.txt et les affiche sur la console.

#inclure #inclure en utilisant l'espace de noms std ; int main() ( ifstream file; // crée un fichier objet stream file.open("test.txt"); // ouvre le fichier en lecture if (!file) return 1; // retourne à l'erreur d'ouverture char str; // Tampon de ligne statique // Lit et affiche les lignes dans une boucle jusqu'à eof while (!file.getline(str, sizeof(str)).eof()) cout<< str << endl; // вывод прочитанной строки на экран cin.sync(); cin.get(); return 0; }

Ce code sous Windows dépend également de la présence d'un caractère de nouvelle ligne dans la dernière ligne du fichier ; il serait plus fiable de faire ceci :

While (1) ( if (file.eof()) break; file.getline(str, sizeof(str)); cout<< str << endl; }

Les appels explicites aux méthodes open et close ne sont pas requis. En effet, appeler le constructeur avec un argument permet d'ouvrir le fichier immédiatement, au moment de la création de l'objet fichier threadé :

Fichier Ifstream("test.txt");

Au lieu de la méthode close, vous pouvez utiliser l'opérateur delete, qui appellera automatiquement le destructeur de l'objet fichier et fermera le fichier. Le code de la boucle while garantit des vérifications appropriées de fin de fichier.

classe ofstream : écriture de fichiers

La classe ofstream est conçue pour générer des données à partir d'un flux de fichiers. Ce qui suit répertorie les principales méthodes de cette classe.

L'opérateur d'inclusion décrit précédemment est pratique pour organiser l'écriture dans un fichier texte :

Fichier Ofstream("temp.txt"); si (!fichier) retourne ; pour (int je=1; je<=3; i++) file << "Строка " << i << endl; file.close();

Fichiers binaires

En principe, les données binaires sont traitées comme des données texte. La différence est que si les données binaires sont écrites dans une structure logique spécifique, elles doivent alors être lues à partir d'un fichier dans une variable du même type de structure.

Le premier paramètre des méthodes d'écriture et de lecture (l'adresse du bloc d'écriture/lecture) doit être du type pointeur de caractère char * , il est donc nécessaire d'effectuer une conversion explicite du type d'adresse de la structure void *. Le deuxième paramètre spécifie que les blocs binaires du fichier ont une taille d'octet constante quelle que soit la longueur réelle de l'enregistrement. L'application suivante fournit un exemple de création et d'affichage de données dans un simple bloc-notes. Les entrées du fichier sont ensuite lues séquentiellement et affichées sur la console.

#inclure #inclure #inclure en utilisant l'espace de noms std ; struct Notes ( // structure de données du notebook char Name; // nom complet char Phone; // phone int Age; // age ); int main() ( setlocale(LC_ALL, "Russe"); Notes Note1= ("Le Terrible Ioann Vasilyevich", "non installé", 60 ); Notes Note2= ("Godunov Boris Fedorovich", "095-111-2233" , 30 ); Notes Note3= ( "Romanov Petr Mikhailovich ", "812-333-2211 ", 20 ); ofstream ofile("Notebook.dat", ios::binary); ofile.write((char*)&Note1, sizeof (Notes)); // 1er bloc ofile.write((char*)&Note2, sizeof(Notes)); // 2ème bloc ofile.write((char*)&Note3, sizeof(Notes)); / / 3ème bloc ofile.close(); // ferme le fichier enregistré ifstream ifile("Notebook.dat", ios::binary); Notes Note; // variable structurée char str; // tampon de chaîne statique // Lit et affiche les lignes dans un boucle jusqu'à eof while (!ifile.read((char*)&Note, sizeof(Notes)).eof()) ( sprintf(str, "%s\tPhone: %s\tAge: %d" , Note.Name, Note.Téléphone, Note.Age); cout<< str << endl; } ifile.close(); // закрыть прочитанный файл cin.sync(); cin.get(); return 0; }

À la suite de l'exécution de ce code, un fichier binaire Notebook.dat est formé de trois blocs de 80 octets chacun (en supposant que les caractères sont à un seul octet). Naturellement, vous pouvez utiliser d'autres méthodes de threading et effectuer n'importe quelle opération sur les champs d'une structure de données spécifique.

Classe fstream : accès aléatoire aux fichiers

Supposons que nous ayons 100 entrées dans notre cahier et que nous souhaitions compter la 50ème. Bien sûr, vous pouvez organiser une boucle et lire tous les enregistrements du premier au suivant. Évidemment, une solution plus ciblée consiste à définir le pointeur de position du fichier pos directement sur l'entrée 50 et à y lire :

Ifstream ifile("Notebook.dat", ios::binary); int pos = 49 * sizeof(Notes); ifile.seekg(pos); // recherche la 50ème entrée Notes Note ; //Notes – la structure « enregistrement » décrite ci-dessus ifile.read((char*)&Note, sizeof(Notes));

De telles opérations de recherche sont efficaces si le fichier est constitué d'enregistrements de taille connue et constante. Pour remplacer le contenu d'un enregistrement arbitraire, vous devez ouvrir le flux de sortie en mode modification :

Ofstream ofile ("Notebook.dat", ios::binary | ios::ate); int pos = 49 * sizeof(Notes); ofile seekp(pos); // recherche de la 50e note Notes Note50 = ("Eltsine Boris Nikolaïevitch", "095-222-3322", 64); ofile.write((char*)&Note, sizeof(Notes)); // remplacement

Si vous ne spécifiez pas le drapeau ios::ate (ou ios::app), alors lorsque vous ouvrirez le fichier binaire Notebook.dat, son contenu précédent sera effacé !

Enfin, il est possible d'ouvrir un fichier simultanément en lecture/écriture, en utilisant les méthodes héritées par la classe streaming fstream de ses prédécesseurs. Puisque la classe fstream est dérivée de istream et ostream (respectivement parents de ifstream et ofstream), toutes les méthodes mentionnées précédemment deviennent disponibles dans l'application.

L'exemple suivant montre le réarrangement des première et troisième entrées du fichier Notebook.dat.

#inclure #inclure #inclure en utilisant l'espace de noms std ; struct Notes (nom du caractère ; char Téléphone ; int Âge ; ); int main() ( setlocale(LC_ALL, "Russe"); Notes Note1, Note3; // Ouvrir le fichier pour lire/écrire simultanément fstream file("Notebook.dat", ios::binary | ios::in | ios: : out); file.seekg(2 * sizeof(Notes)); // recherche et lit Note3 file.read((char*)&Note3, sizeof(Notes)); file.seekg(0); // recherche et lecture Note1 file.read((char*)&Note1, sizeof(Notes)); file.seekg(0); // Note1<== Note3 file.write((char*)&Note3, sizeof(Notes)); file.seekg(2 * sizeof(Notes)); // Note3 <== Note1 file.write((char*)&Note1, sizeof(Notes)); char str; // Считывать и отображать записи в цикле, пока не eof file.seekg(0); // вернуться к началу файла while (!file.read((char*)&Note1, sizeof(Notes)).eof()) { sprintf(str, "%s\tТел: %s\tВозраст: %d", Note1.Name, Note1.Phone, Note1.Age); cout << str << endl; } file.close(); cin.sync(); cin.get(); return 0; }

Dans le constructeur de l'objet fichier, vous devez spécifier les indicateurs ios::in et ios::out, permettant des opérations de lecture et d'écriture simultanées. Suite à l'exécution de ce code, les première et troisième entrées du fichier binaire Notebook.dat seront échangées.

Il existe des exemples supplémentaires sur le sujet.

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 main () ( FILE * fichier; struct food ( char name[ 20 ] ; quantité non signée; float price; ) ; struct food shop[ 10 ] ; char i= 0 ; file = fopen ( "fscanf.txt", "r" ) ; while (fscanf (file, "%s%u%f" , shop[ i].name , & (shop[ i].qty ) , & (shop[ i].price ) ) != EOF) ( printf ("%s %u %.2f \n", boutique[i].nom, boutique[i].qté, boutique[i].prix) ; je++; ) )

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 #define N 80 main () ( FILE * file; char arr[ N] ; file = fopen ( "fscanf.txt" , "r" ) ; while (fgets (arr, N, file) != NULL) printf (" %s" , arr) ; printf (" \n") ; fclose(fichier); )

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 #inclure main () ( FILE * fichier; char Shelf1[ 50 ], Shelf2[ 100 ] ; int n, m; file = fopen ("shelf1.txt" , "rb" ) ; n= fread (shelf1, sizeof (char ) , 50 , fichier) ; fclose (fichier) ; fichier = fopen ("shelf2.txt" , "rb" ) ; m= fread (shelf2, sizeof (char ) , 50 , fichier) ; fclose (fichier) ; étagère1[ n] = " \0 " ; étagère2[m] = " \n"; étagère2[ m+ 1 ] = " \0 " ; fichier = fopen ("shop.txt" , "wb" ) ; fwrite (strcat (étagère2, étagère1) , sizeof (char ) , n+ m, fichier) ; fclose(fichier); )

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.

Dernière mise à jour : 31/10/2015

Il existe deux classes conçues pour fonctionner avec des répertoires dans l'espace de noms System.IO : Directory et DirectoryInfo.

Classe d'annuaire

La classe Directory fournit un certain nombre de méthodes statiques pour gérer les répertoires. Certaines de ces méthodes :

CreateDirectory(path) : crée un répertoire au chemin spécifié

Supprimer(chemin) : supprime le répertoire au chemin spécifié

Exists(path) : Détermine si le répertoire au chemin spécifié existe. S'il existe, vrai est renvoyé, s'il n'existe pas, alors faux

GetDirectories(path) : obtient une liste de répertoires dans le chemin du répertoire

GetFiles(path) : obtient une liste de fichiers dans le chemin du répertoire

Déplacer (NomRepsource, NomRepdest): déplace un répertoire

GetParent(path) : Récupère le répertoire parent

Classe DirectoryInfo

Cette classe fournit des fonctionnalités pour la création, la suppression, le déplacement et d'autres opérations de répertoire. À bien des égards, il ressemble à Directory. Certaines de ses propriétés et méthodes :

Create() : Crée un répertoire

CreateSubdirectory(path) : Crée un sous-répertoire au chemin spécifié

Supprimer() : supprime un répertoire

Propriété Exists : détermine si un répertoire existe

GetDirectories() : Obtient une liste de répertoires

GetFiles() : Obtient une liste de fichiers

MoveTo(destDirName) : Déplace un répertoire

Propriété parent : obtenir le répertoire parent

Propriété racine : obtenir le répertoire racine

Regardons des exemples d'utilisation de ces classes

Obtenir une liste de fichiers et sous-répertoires

chaîne dirName = "C:\\"; if (Directory.Exists(dirName)) ( Console.WriteLine("Subdirectories:"); string dirs = Directory.GetDirectories(dirName); foreach (string s in dirs) ( Console.WriteLine(s); ) Console.WriteLine( ); Console.WriteLine("Files:"); string files = Directory.GetFiles(dirName); foreach (chaîne s dans les fichiers) ( Console.WriteLine(s); ) )

Veuillez noter l'utilisation de barres obliques dans les noms de fichiers. Soit on utilise une double barre oblique : "C:\\" soit une simple barre oblique, mais ensuite on met le signe @ devant le chemin complet : @"C:\Program Files"

Création d'un répertoire

chemin de chaîne = @"C:\SomeDir"; sous-chemin de chaîne = @"program\avalon"; DirectoryInfo dirInfo = new DirectoryInfo(chemin); if (!dirInfo.Exists) ( dirInfo.Create(); ) dirInfo.CreateSubdirectory(sous-chemin);

Tout d’abord, nous vérifions si un tel répertoire existe, car s’il existe, il ne sera pas possible de le créer et l’application générera une erreur. En conséquence, nous obtiendrons le chemin suivant : "C:\SomeDir\program\avalon"

Obtenir des informations sur l'annuaire

string dirName = "C:\\Program Files" ; DirectoryInfo dirInfo = new DirectoryInfo(dirName); Console.WriteLine($"Nom du répertoire : (dirInfo.Name)"); Console.WriteLine($"Nom complet du répertoire : (dirInfo.FullName)"); Console.WriteLine($"Heure de création du répertoire : (dirInfo.CreationTime)"); Console.WriteLine($"Répertoire racine : (dirInfo.Root)");

Supprimer un répertoire

Si nous appliquons simplement la méthode Supprimer à un dossier non vide contenant des fichiers ou des sous-répertoires, l'application générera une erreur. Par conséquent, nous devons passer un paramètre de type booléen supplémentaire à la méthode Delete, qui indiquera que le dossier doit être supprimé avec tout son contenu :

String dirName = @"C:\SomeFolder"; essayez ( DirectoryInfo dirInfo = new DirectoryInfo(dirName); dirInfo.Delete(true); Console.WriteLine("Répertoire supprimé"); ) catch (Exception ex) ( Console.WriteLine(ex.Message); )

String dirName = @"C:\SomeFolder"; Directory.Delete(dirName, true);

Déplacer un répertoire

chaîne oldPath = @"C:\SomeFolder"; string newPath = @"C:\SomeDir"; DirectoryInfo dirInfo = new DirectoryInfo(oldPath); if (dirInfo.Exists && Directory.Exists(newPath) == false) ( dirInfo.MoveTo(newPath); )

Lors du déplacement, nous devons tenir compte du fait que le nouveau répertoire dans lequel nous voulons déplacer tout le contenu de l'ancien répertoire ne doit pas exister.