Pour plus de commodité, les informations dans les périphériques de stockage sont stockées sous forme de fichiers.
Fichier - zone nommée mémoire externe dédié au stockage du tableau de données. Les données contenues dans les fichiers sont de la nature la plus variée : programmes en langage algorithmique ou machine ; les données initiales pour le fonctionnement des programmes ou les résultats de l'exécution des programmes ; textes arbitraires; images graphiques etc.
Répertoire (dossier, répertoire) - une collection nommée d'octets sur un support de stockage, contenant le nom des sous-répertoires et des fichiers, est utilisée dans le système de fichiers pour simplifier l'organisation des fichiers.
Système de fichiers appelé partie fonctionnelle système opérateur, qui permet l'exécution d'opérations sur des fichiers. Des exemples de systèmes de fichiers sont FAT (FAT - File Allocation Table), NTFS, UDF (utilisé sur les CD).
Il existe trois versions principales de FAT : FAT12, FAT16 et FAT32. Ils diffèrent par la profondeur de bits des enregistrements dans la structure du disque, c'est-à-dire le nombre de bits alloués pour stocker le numéro de cluster. FAT12 est principalement utilisé pour les disquettes (jusqu'à 4 Ko), FAT16 pour les petits disques, FAT32 pour les lecteurs FLASH de grande capacité (jusqu'à 32 Go).
Considérez la structure système de fichiers en utilisant FAT32 comme exemple.
Structure de fichier FAT32
Les dispositifs de mémoire externes dans le système FAT32 n'ont pas d'adressage d'octet, mais de bloc. Les informations sont écrites sur le périphérique de mémoire externe en blocs ou en secteurs.
Un secteur est la plus petite unité adressable de stockage d'informations sur des périphériques de stockage externes. Typiquement, la taille du secteur est fixée à 512 octets. Pour augmenter l'espace d'adressage des périphériques de mémoire externes, les secteurs sont combinés en groupes appelés clusters.
Un cluster est une union de plusieurs secteurs, qui peuvent être considérés comme une unité indépendante avec certaines propriétés. La principale propriété d'un cluster est sa taille, mesurée en nombre de secteurs ou en nombre d'octets.
Le système de fichiers FAT32 a la structure suivante.
Les clusters utilisés pour l'enregistrement des fichiers sont numérotés à partir de 2. En règle générale, le cluster #2 est utilisé par le répertoire racine, et à partir du cluster #3, un tableau de données est stocké. Les secteurs utilisés pour stocker les informations présentées au-dessus du répertoire racine ne sont pas regroupés.
La taille minimale du fichier sur le disque est de 1 cluster.
Le secteur de démarrage commence par les informations suivantes :
- EB 58 90 - branche et signature inconditionnelles ;
- 4D 53 44 4F 53 35 2E 30 MSDOS5.0 ;
- 00 02 - le nombre d'octets dans le secteur (généralement 512);
- 1 octet - le nombre de secteurs dans le cluster ;
- 2 octets - le nombre de secteurs de réserve.
De plus, le secteur de démarrage contient les informations importantes suivantes :
- 0x10 (1 octet) - nombre de tables FAT (généralement 2);
- 0x20 (4 octets) - le nombre de secteurs sur le disque ;
- 0x2С (4 octets) - numéro du cluster du répertoire racine ;
- 0x47 (11 octets) - étiquette de volume ;
- 0x1FE (2 octets) - signature du secteur de démarrage (55 AA).
Le secteur d'informations du système de fichiers contient :
- 0x00 (4 octets) - signature (52 52 61 41);
- 0x1E4 (4 octets) - signature (72 72 41 61);
- 0x1E8 (4 octets) - nombre de clusters libres, -1 si inconnu ;
- 0x1EC (4 octets) - numéro du dernier cluster enregistré ;
- 0x1FE (2 octets) - signature (55 AA).
Le FAT contient des informations sur l'état de chaque cluster sur le disque. Les 2 octets inférieurs du FAT stockent F8 FF FF 0F FF FF FF FF (ce qui correspond à l'état des clusters 0 et 1, qui sont physiquement absents). De plus, l'état de chaque cluster contient le numéro du cluster dans lequel le fichier actuel continue ou les informations suivantes :
- 00 00 00 00 - le cluster est libre ;
- FF FF FF 0F - fin du fichier courant.
- 8 octets - nom de fichier ;
- 3 octets - extension de fichier ;
Le répertoire racine contient un ensemble d'enregistrements d'informations 32 bits pour chaque fichier, contenant les informations suivantes :
Lorsque vous travaillez avec des noms de fichiers longs (y compris des noms russes), le nom de fichier est codé dans le système de codage UTF-16. Dans ce cas, 2 octets sont alloués pour encoder chaque caractère. Dans ce cas, le nom du fichier est écrit sous la forme de la structure suivante :
- 1 octet de séquence ;
- 10 octets contiennent les 5 caractères les moins significatifs du nom de fichier ;
- attribut 1 octet ;
- 1 octet réservé ;
- 1 octet - somme de contrôle nom DOS ;
- 12 octets contiennent les 3 caractères les moins significatifs du nom de fichier ;
- 2 octets - numéro du premier cluster ;
- autres caractères du nom long.
Travailler avec des fichiers en langage C
Pour un programmeur fichier ouvert est représenté comme une séquence de données en cours de lecture ou d'écriture. Lorsqu'un fichier est ouvert, il est associé à Flux d'E/S... Les informations de sortie sont écrites dans le flux, les informations d'entrée sont lues à partir du flux.
Lorsqu'un flux est ouvert pour les E/S, il s'associe à une structure standard de type FILE, qui est définie dans stdio.h. La structure FILE contient information nécessaire sur le fichier.
Le fichier est ouvert à l'aide de la fonction fopen (), qui renvoie un pointeur vers une structure FILE, qui peut être utilisée pour des opérations ultérieures avec le fichier.
FICHIER * fopen (nom, type);
name - le nom du fichier à ouvrir (y compris le chemin),
type est un pointeur vers une chaîne de caractères qui détermine comment accéder au fichier :
- "r" - ouvre un fichier en lecture (le fichier doit exister);
- "w" - ouvre un fichier vide pour l'écriture ; si le fichier existe, alors son contenu est perdu ;
- "a" - ouvre le fichier pour l'écriture jusqu'à la fin (pour l'ajout); le fichier est créé s'il n'existe pas ;
- "r +" - ouvre un fichier en lecture et en écriture (le fichier doit exister);
- "w +" - ouvre un fichier vide pour la lecture et l'écriture ; si le fichier existe, alors son contenu est perdu ;
- "a +" - ouvre le fichier pour lecture et ajout, si le fichier n'existe pas, alors il est créé.
La valeur de retour est un pointeur vers le flux ouvert. Si une erreur est rencontrée, NULL est renvoyé.
La fonction fclose() ferme le ou les flux associés aux fichiers ouverts avec fopen(). Le flux à fermer est déterminé par l'argument de la fonction fclose().
Valeur renvoyée : valeur 0, si le flux a été fermé avec succès ; EOF constant si une erreur s'est produite.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#inclure
int main () (
FICHIER * fp;
nom de caractère = "mon.txt" ;
if ((fp = fopen (nom, "r")) == NULL)
{
printf ( "Impossible d'ouvrir le fichier");
getchar ();
renvoie 0 ;
}
// ouvre le fichier avec succès
... // actions requises sur les données
ffermer (fp);
getchar ();
renvoie 0 ;
}
Lire un caractère dans un fichier:
char fgetc (flux);
L'argument de fonction est un pointeur vers un flux de type FICHIER. La fonction renvoie le code du caractère lu. Si la fin du fichier est atteinte ou si une erreur se produit, la constante EOF est renvoyée.
Ecrire un caractère dans un fichier:
fputc (caractère, flux);
Les arguments de la fonction sont un caractère et un pointeur vers un flux de type FICHIER. La fonction renvoie le code du caractère lu.
Les fonctions fscanf () et fprintf () sont similaires aux fonctions scanf () et printf (), mais elles fonctionnent avec des fichiers de données et ont un pointeur de fichier comme premier argument.
fscanf (flux, "Format d'entrée", arguments);
Dans cet article, nous allons apprendre à lire des données à partir de fichiers et à écrire des informations dans des fichiers dans des programmes C. Fichiers dans si servent à sauvegarder le résultat du programme C et à l'utiliser au redémarrage du programme. Par exemple, vous pouvez enregistrer les résultats des calculs, les statistiques de jeu.
Pour travailler avec des fichiers en C, vous devez connecter la bibliothèque stdio.h
#inclure
Travailler avec fichier dans si vous devez définir un pointeur de fichier en fonction de l'échantillon
FILE * le nom du pointeur de fichier ;
par exemple
FICHIER * aileron ;
Définit 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 du fichier, vous pouvez sélectionner le fichier avec le clic de souris sur bouton de droite souris et sélectionnez les propriétés du fichier. Dans la section Emplacement, le chemin d'accès au fichier sera répertorié. Notez qu'en C, le chemin est indiqué par deux barres obliques.
Après avoir travaillé avec un fichier en C, vous devez le fermer à l'aide de la commande
fclose (nom du pointeur de fichier)
Lire les informations d'un fichier texte en C
Pour pouvoir lire les caractères russes à partir 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 dans si la commande fscanf() est utilisée. Cette commande est similaire à la commande de saisie d'informations depuis le clavier, seul le premier paramètre est un pointeur de 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 à partir du fichier, qui est lié au pointeur de fichier fin, une ligne de trois variables entières
Regardons un exemple de programme qui lit à partir de fichier texte data.txt dans lequel trois colonnes de chiffres sont des informations écrites et les écrit dans des tableaux. Chaque colonne d'informations a son propre tableau. Détails sur.
#inclure
#inclure
principale ()
(entier un;
int b;
int c;
int je;
// définit un pointeur de fichier
FICHIER * aileron ;
// ouvre le fichier en lecture
fin = fopen ("C: \\ Users \\ user \\ Desktop \\ data.txt", "r");
// lecture ligne par ligne du fichier
pour (i = 0; je<3;i++)
{
// lit une chaîne de trois valeurs de fichier et écrit dans des tableaux
fscanf (fin, "% d% d% d", & a [i], & b [i], & c [i]);
}
// affiche les tableaux à l'écran
pour (i = 0; je<3;i++)
{
printf ("% d% d% d", a [i], b [i], c [i]);
}
getch ();
// ferme le fichier
fclose (fin);
}
Lecture des informations d'un fichier ligne par ligne dans la fonction C. Fgets ()
L'opérateur fscanf () lit un mot dans un fichier, c'est-à-dire jusqu'au premier espace venant en sens inverse.
Pour lire la ligne entière d'un fichier à partir d'un fichier, C utilise 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
principale ()
{
// définir les variables de chaîne
caractère st1 ;
caractère st2 ;
// définit un pointeur de fichier
FICHIER * aileron ;
// mettre en place le travail avec le 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 pour la lecture
fclose (fin);
}
Écrire des informations dans un fichier texte en C
Pour écrire des données déposer en C, vous devez ouvrir le fichier en mode écriture
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 C, seul le premier paramètre est un pointeur de 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 et leur somme dans le fichier out.txt
#inclure
#inclure
principale ()
(entier un;
int b;
int c;
FICHIER * fout;
fout = fopen ("C: \\ Users \\ user \\ Desktop \\ out.txt", "w");
printf ("entrez le premier nombre");
scanf ("% d", & a);
printf ("entrez le deuxième nombre");
scanf ("% d", & b);
c = a + b ;
fprintf (fout, "% d% d% d", a, b, c);
getch ();
fclose (fout);
}
Avant cela, lors des E/S de données, nous travaillions avec des flux standards - un clavier et un moniteur. Voyons maintenant comment le langage C implémente la réception de données à partir de fichiers et leur écriture. Avant d'effectuer ces opérations, vous devez ouvrir le fichier et y accéder.
Dans le langage de programmation C, un pointeur de fichier est de type FILE et sa déclaration ressemble à ceci :
FICHIER * monfichier ;
D'autre part, la fonction fopen () ouvre le fichier à l'adresse spécifiée en tant que premier argument en mode lecture ("r"), écriture ("w") ou ajout ("a") et renvoie un pointeur vers celui-ci dans le 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, il est accessible via un pointeur de fichier (dans ce cas, monfichier).
Si pour une raison quelconque (il n'y a pas de fichier à l'adresse spécifiée, l'accès est refusé) la fonction fopen() ne peut pas ouvrir le fichier, alors elle renvoie NULL. Dans les vrais programmes, l'erreur d'ouverture d'un fichier dans la branche if est presque toujours gérée, mais nous l'omettreons plus loin.
La déclaration de fonction fopen() est contenue dans le fichier d'en-tête stdio.h, elle doit donc être incluse. Le type de structure FILE est également déclaré dans stdio.h.
Une fois le travail avec le fichier terminé, il est d'usage de le fermer afin de libérer le tampon de 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 est effectuée à l'aide de la fonction fclose (). Un pointeur de fichier lui est passé en paramètre :
fclose (monfichier);
Plusieurs fichiers peuvent être ouverts 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 le deuxième fichier.
Lecture et écriture dans un fichier texte
fscanf ()
La fonction fscanf () a une signification similaire à la fonction scanf (), mais contrairement à elle, elle reçoit une entrée formatée d'un fichier plutôt qu'une entrée standard. La fonction fscanf() prend des paramètres : un pointeur de fichier, une chaîne de format, des adresses de zones mémoire pour l'écriture des données :
fscanf (monfichier, "% s% d", str, & a);
Renvoie la quantité de données lues avec succès ou EOF. Les espaces, les caractères de nouvelle ligne sont comptés comme séparateurs de données.
Disons que nous avons un fichier contenant la description suivante des objets :
Pommes 10 23,4 bananes 5 25,0 pain 1 10,3
#inclure
Dans ce cas, une structure et un tableau de structures sont déclarés. Chaque ligne du fichier correspond à un élément du tableau ; un élément de tableau est une structure contenant une chaîne et deux champs numériques. La boucle lit une ligne par itération. Lorsque la fin du fichier est rencontrée, fscanf () renvoie EOF et la boucle se termine.
fgets ()
La fonction fgets () est similaire à la fonction gets () et prend l'entrée ligne par ligne d'un fichier. Un appel fgets() lira une ligne. Dans ce cas, vous pouvez lire non pas la ligne entière, mais seulement une partie depuis le début. Les paramètres Fgets() ressemblent à ceci :
fgets (char_array, nombre de caractères à lire, pointer_ to file)
Par exemple:
fgets (str, 50, monfichier)
Un tel 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, en tenant compte du caractère "\ n", que la fonction stockera également dans le tableau. Le dernier (50e) élément du tableau str sera le caractère "\ 0" ajouté par fgets (). Si la chaîne est plus longue, la fonction lira 49 caractères et écrira "\ 0" à la fin. Dans ce cas, "\ n" ne sera pas contenu dans la ligne de lecture.
#inclure
Dans ce programme, contrairement au précédent, les données sont lues ligne par ligne dans le tableau arr. A la lecture de la ligne suivante, la précédente est perdue. La fonction fgets() renvoie NULL si elle ne peut pas lire la ligne suivante.
getc () ou fgetc ()
La fonction getc () ou fgetc () (les deux fonctionnent) vous permet d'obtenir le caractère suivant du fichier.
while ((arr [i] = fgetc (fichier))! = EOF) (if (arr [i] == " \ n ") (arr [i] = " \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
En plus de l'entrée, la sortie vers le fichier peut être différente.
- Sortie formatée. Fonction Fprintf (file_pointer, format_string, variables).
- Sortie ligne par ligne. Fonction fputs (string, file_pointer).
- Sortie caractère par caractère. Fputc () ou putc (char, file_pointer).
Vous trouverez ci-dessous des exemples de code qui utilisent trois manières de générer des données dans un fichier.
Ecriture des champs d'une structure à 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 (file, " % s% u% .2f \ n ", shop [i] .name, shop [i] .qty, shop [i] .price); je ++; )
Sortie ligne par ligne dans un fichier (fputs (), contrairement à puts () lui-même ne place pas "\ n" à la fin de la ligne):
while (gets (arr)! = NULL) (fputs (arr, file); fputs (" \ n ", déposer); )
Un exemple de sortie caractère par caractère :
while ((i = getchar ())! = EOF) putc (i, fichier);
Lecture et écriture à partir d'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 est impossible de travailler différemment avec des fichiers non texte. Cependant, vous pouvez lire et écrire dans des fichiers texte de cette façon. L'avantage de ce mode d'accès à un fichier est la vitesse de lecture-écriture : un seul accès permet de lire/écrire un bloc d'informations important.
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 les binaires est assez complexe et nécessite une leçon distincte pour l'apprendre. On ne notera ici que les particularités des fonctions de lecture et d'écriture dans un fichier, qui est considéré comme un flux d'octets.
Les fonctions fread() et fwrite() prennent comme paramètres :
- l'adresse de la zone mémoire où les données sont écrites ou lues,
- la taille d'un type donné,
- la quantité de données à lire de la taille spécifiée,
- pointeur de fichier.
Ces fonctions renvoient le nombre de données lues ou écrites avec succès. Celles. vous pouvez "commander" la lecture de 50 éléments de données, et n'en obtenir que 10. Il n'y aura pas d'erreurs.
Un exemple d'utilisation des fonctions fread() et fwrite() :
#inclure
Ici, une tentative est faite pour lire 50 caractères à partir du premier fichier. N stocke le nombre de caractères réellement lus. N peut être égal ou inférieur à 50. Les données sont mises dans une chaîne. 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ésoudre les problèmes
- Ecrivez 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.
- Écrire un programme qui écrit des données dans un fichier reçu d'un autre fichier et modifié d'une manière ou d'une autre avant d'écrire. Chaque ligne de données reçue d'un fichier doit s'inscrire dans une structure.
Dernière mise à jour : 31.10.2015
Il existe deux classes pour travailler 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 la gestion des répertoires. Certaines de ces méthodes sont :
CreateDirectory (path) : crée un répertoire au chemin spécifié
Supprimer (chemin): supprime le répertoire au chemin spécifié
Existe (chemin) : détermine si un répertoire existe au chemin spécifié. S'il existe, il renvoie vrai, s'il n'existe pas, alors faux
GetDirectories (path) : obtient une liste des répertoires dans le répertoire path
GetFiles (chemin) : obtient une liste des fichiers dans le répertoire du chemin
Déplacer (sourceDirName, destDirName): déplace le répertoire
GetParent (chemin) : obtenir 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 avec des répertoires. À bien des égards, il est similaire à Directory. Certaines de ses propriétés et méthodes :
Créer () : 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 le 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 de sous-répertoires
string dirName = "C: \\"; if (Directory.Exists (dirName)) (Console.WriteLine ("Sous-répertoires :"); string dirs = Directory.GetDirectories (dirName); foreach (string s in dirs) (Console.WriteLine (s);) Console.WriteLine ( ); Console.WriteLine ("Fichiers :"); string files = Directory.GetFiles (dirName); foreach (string s in files) (Console.WriteLine (s);))Notez l'utilisation de barres obliques dans les noms de fichiers. Soit on utilise un double slash : "C: \\", soit un simple, mais ensuite on met le signe @ devant tout le chemin : @ "C: \ Program Files"
Créer un répertoire
chemin de chaîne = @ "C: \ SomeDir"; string subpath = @ "programme \ avalon" ; DirectoryInfo dirInfo = new DirectoryInfo (chemin) ; if (! dirInfo.Exists) (dirInfo.Create ();) dirInfo.CreateSubdirectory (sous-chemin);Tout d'abord, nous vérifions s'il existe un tel répertoire, 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 obtenons le chemin suivant : "C: \ SomeDir \ program \ avalon"
Récupération des informations du répertoire
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 Delete à un dossier non vide contenant des fichiers ou des sous-répertoires, l'application nous renverra une erreur. Par conséquent, nous devons passer un paramètre booléen supplémentaire à la méthode Delete, qui indiquera que le dossier doit être supprimé avec tout son contenu :
String dirName = @ "C: \ SomeFolder"; try (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
string 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, il convient de garder à l'esprit que le nouveau répertoire, dans lequel nous voulons déplacer tout le contenu de l'ancien répertoire, ne doit pas exister.
Le travail des E/S de fichiers en C++ est quasiment le même que d'habitude (mais avec quelques nuances).
Classes d'E/S de fichiers
Il y a les trois principales classes d'E/S de fichiers en C++:
hors flux(est un enfant de la classe);
fstream(est un enfant de la classe iostream).
Vous pouvez utiliser ces classes pour effectuer une entrée de fichier unidirectionnelle, une sortie de fichier unidirectionnelle et des E/S de fichier bidirectionnelles. Pour les utiliser, il vous suffit de vous connecter à fstream.
Contrairement aux flux cout, cin, cerr et clog, qui peuvent être utilisés immédiatement, les flux de fichiers doivent être explicitement définis par le programmeur. C'est-à-dire que pour ouvrir un fichier en lecture et/ou en écriture, vous devez créer un objet de la classe d'E/S du fichier correspondant, en spécifiant le nom du fichier en paramètre. Ensuite, en utilisant les opérateurs d'insertion (<<) или извлечения (>>), vous pouvez écrire des données dans un fichier ou lire le contenu d'un fichier. Après cela, le final est - vous devez fermer le fichier : appelez explicitement méthode close () ou laissez simplement la variable d'E/S de fichier hors de portée (la classe d'E/S de fichier fermera automatiquement ce fichier pour nous).
Sortie de fichier
La classe ofstream est utilisée pour écrire dans un fichier. Par exemple:
#inclure
#inclure #inclure #inclure int main () en utilisant l'espace de noms std ; // ofstream est utilisé pour écrire des données dans un fichier // Créer un fichier SomeText.txt ofstream outf ("SomeText.txt"); // Si nous ne pouvons pas ouvrir ce fichier pour y écrire des données si (! outf) // Ensuite, nous affichons un message d'erreur et exécutons exit() cerr<< << endl ; sortie (1) ; // Écrivez les deux lignes suivantes dans le fichier hors<< "See line #1!" << endl ; hors<< "See line #2!" << endl ; renvoie 0 ; // Lorsque outf sort de la portée, le destructeur de la classe ofstream fermera automatiquement notre fichier |
Si vous regardez dans votre répertoire de projet ( Faites un clic droit sur l'onglet avec le nom de votre fichier .cpp dans Visual Studio > "Ouvrir dossier contenant"), vous verrez un fichier nommé SomeText.txt, qui contient les lignes suivantes :
Voir ligne #1 !
Voir ligne #2 !
Veuillez noter que nous pouvons également utiliser méthode put() pour écrire un caractère dans un fichier.
Saisie de fichier
#inclure
#inclure #inclure #inclure #inclure int main () en utilisant l'espace de noms std ; // ifstream est utilisé pour lire le contenu du fichier // Si on ne peut pas ouvrir ce fichier pour lire son contenu si (! inf) // Ensuite, nous affichons le message d'erreur suivant et exécutons exit () cerr<< << endl ; sortie (1) ; // Bien qu'il y ait des données que nous pouvons lire tandis que (inf) // Ensuite, nous déplaçons ces données dans une ligne, que nous affichons ensuite à l'écran chaîne strInput; inf >> strInput; cout<< strInput << endl ; renvoie 0 ; // Quand inf sort de la portée, le destructeur de la classe ifstream fermera automatiquement notre fichier |
Voir
ligne
#1!
Voir
ligne
#2!
Hmm, ce n'est pas exactement ce que nous voulions. Comme nous le savons déjà des leçons précédentes, l'opérateur d'extraction travaille avec des "données formatées", c'est-à-dire il ignore tous les espaces, tabulations et sauts de ligne. Pour lire l'intégralité du contenu tel quel, sans le décomposer en parties (comme dans l'exemple ci-dessus), nous devons utiliser méthode getline():
#inclure
#inclure #inclure #inclure #inclure int main () en utilisant l'espace de noms std ; // ifstream est utilisé pour lire le contenu des fichiers ifstream inf ("SomeText.txt"); // Si on ne peut pas ouvrir le fichier pour lire son contenu si (! inf) // Ensuite, nous affichons le message d'erreur suivant et exécutons exit () cerr<< "Euh oh, SomeText.txt n'a pas pu être ouvert pour la lecture !"<< endl ; sortie (1) ; tandis que (inf) chaîne strInput; getline (inf, strInput); cout<< strInput << endl ; renvoie 0 ; // Quand inf sort de la portée, le destructeur de la classe ifstream fermera automatiquement notre fichier |
Le résultat de l'exécution du programme ci-dessus :
Sortie tamponnée
La sortie C++ peut être mise en mémoire tampon. Cela signifie que tout ce qui est sorti dans le flux de fichiers ne peut pas être immédiatement écrit sur le disque (dans un fichier spécifique). Ceci est fait principalement pour des raisons de performance. Lorsque les données du tampon sont écrites sur le disque, elles sont appelées purge du tampon... Une façon d'effacer le tampon est de fermer le fichier. Dans ce cas, tout le contenu du tampon sera déplacé sur le disque, puis le fichier sera fermé.
La mise en mémoire tampon de sortie n'est généralement pas un problème, mais dans certaines circonstances, elle peut causer des problèmes aux novices imprudents. Par exemple, lorsque des données sont stockées dans un buffer et que le programme termine son exécution prématurément (soit à la suite d'un échec, soit en appelant). Dans de tels cas, les destructeurs de classe d'E/S de fichiers ne sont pas exécutés, les fichiers ne sont jamais fermés, les tampons ne sont pas vidés et nos données sont perdues à jamais. C'est pourquoi c'est une bonne idée de fermer explicitement tous les fichiers ouverts avant d'appeler exit().
Le tampon peut également être rincé manuellement à l'aide ostream :: méthode flush() ou en envoyant std :: chasse d'eau au flux de sortie. N'importe laquelle de ces méthodes peut être utile pour garantir que le contenu du tampon est écrit sur le disque immédiatement en cas de plantage du programme.
Une nuance intéressante: Depuis std :: endl; efface également le flux de sortie, son utilisation excessive (conduisant à des vidages de tampon inutiles) peut affecter les performances du programme (puisque le vidage du tampon peut dans certains cas être une opération coûteuse). Pour cette raison, les programmeurs soucieux des performances de leur code utilisent souvent \ n au lieu de std :: endl pour insérer une nouvelle ligne dans le flux de sortie afin d'éviter un vidage inutile de la mémoire tampon.
Modes d'ouverture de fichiers
Que se passe-t-il si nous essayons d'écrire des données dans un fichier existant ? Le redémarrage du programme ci-dessus (le tout premier) montre que le fichier d'origine est complètement écrasé lorsque le programme est redémarré. Et si nous devons ajouter des données à la fin du fichier ? Il s'avère que le flux de fichiers prend un deuxième paramètre facultatif qui permet au programmeur de dire au programmeur comment ouvrir le fichier. Comme ce paramètre, vous pouvez passer drapeaux suivants(qui sont dans la classe ios):
application- ouvre le fichier en mode ajout ;
a mangé- va à la fin du fichier avant lecture/écriture ;
binaire- ouvre le fichier en mode binaire (au lieu du mode texte) ;
dans- ouvre le fichier en lecture (par défaut pour ifstream) ;
en dehors- ouvre le fichier en mode enregistrement (par défaut pour ofstream) ;
tronc- supprime le fichier s'il existe déjà.
Vous pouvez spécifier plusieurs indicateurs à la fois en utilisant.
ifstream fonctionne sous ios :: en mode par défaut ;
ofstream fonctionne sous ios :: mode out par défaut ;
fstream s'exécute par défaut en mode ios :: in OR ios :: out, ce qui signifie que vous pouvez à la fois lire le contenu d'un fichier et écrire des données dans un fichier.
Maintenant, écrivons un programme qui ajoute deux lignes au fichier SomeText.txt précédemment créé :
#inclure
#inclure #inclure #inclure int main () en utilisant l'espace de noms std ; // Passez le drapeau ios: app pour dire à fstream que nous allons ajouter nos données aux données du fichier existant, // nous n'allons pas écraser le fichier. Nous n'avons pas besoin de passer le drapeau ios :: out, // puisque ofstream fonctionne sous ios :: mode out par défaut ofstream outf ("SomeText.txt", ios :: app); // Si nous ne pouvons pas ouvrir le fichier pour écrire des données si (! outf) // Ensuite, nous affichons le message d'erreur suivant et exécutons exit () cerr<< "Euh oh, SomeText.txt n'a pas pu être ouvert pour l'écriture !"<< endl ; sortie (1) ; |
