Création d'un fichier c#. Classe de flux : enregistrement de fichiers. classe ifstream : lecture de fichiers

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 massivement 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. boucle while(1) est utilisé à 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 ;<< 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 du 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); sizeof (Notes)); // 1er bloc de fichier.write((char*)&Note2, sizeof(Notes)); // 2ème bloc de fichier.write((char*)&Note3, sizeof(Notes)); .close(); // ferme le fichier enregistré ifstream ifile("Notebook.dat", ios::binary); // variable structurée char str; // lit et affiche les lignes en boucle jusqu'à eof while (!ifile.read((char*)&Note, sizeof(Notes)).eof()) ( sprintf(str, "%s\tPhone : %s\tAge : %d" , Note.Name, Note.Phone, Remarque.Âge);<< 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 note Notes ;

//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 50ème entrée 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.

#inclure #inclure #inclure L'exemple suivant montre le réarrangement des première et troisième entrées du fichier Notebook.dat.<== 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; }

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)); *)&Note1, taille de (Notes)); fichier.seekg(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.

Cette section couvrira deux façons de travailler avec des fichiers et la classe standard MFC CFileDialog.

#inclure
#inclure

1. Travailler avec des fichiers en C (fonctionne également en C++).
{
Vide principal(vide)
FICHIER *fichier ;
char* nom_fichier = "fichier.txt";

char load_string = "aucun";

Fichier = fopen(nom_fichier, "w");

Fichier = fopen(nom_fichier, "r");
si(fichier != 0)
{
fgets(load_string, 50, fichier);
cout)
autre
{
cout)
fclose(fichier);
) Les descriptions des fonctions pour travailler avec des fichiers se trouvent dans la bibliothèque stdio.h
Vous devez d’abord créer un pointeur vers une variable de type FILE ( FICHIER* fichier ;).
L'ouverture d'un fichier se fait en appelant la fonction fopen ( fichier = fopen(nom_fichier, "w");)
Le premier paramètre de cette fonction est le nom du fichier, le second précise dans quel mode le fichier doit être ouvert. "w"- ouvert pour l'enregistrement, "r"- ouvert à la lecture, "un"- ajout de fichiers (ce sont les modes les plus utilisés, bien qu'il en existe d'autres). L'écriture et la lecture des données d'un fichier s'effectuent par les fonctions suivantes : fputc, fputs, fgetc, fgets, fprintf, fscanf(pour une description de ces fonctions, voir stdio.h).
La fermeture d'un fichier se fait en appelant la fonction fclose ( fclose(fichier);).

Travailler avec des fichiers utilisant MFC (classes CFile, CStdioFile, ...) et la classe MFC standard CFileDialog.

La bibliothèque MFC comprend plusieurs classes pour travailler avec des fichiers. Les classes décrites ci-dessous héritent de la classe de base

Fichier CF.

Fichier de classe CF

Fichier CFconçu pour fonctionner avec des fichiers. Il facilite l'utilisation des fichiers en représentant un fichier comme un objet pouvant être créé, lu, écrit, etc.

Pour accéder à un fichier, vous devez d'abord créer un objet de la classe CFile. Le constructeur de classe vous permet d'ouvrir un fichier immédiatement après avoir créé un tel objet. Mais vous pourrez ouvrir le fichier plus tard en utilisant la méthode

Ouvrir.

Ouverture et création de fichiers

Après avoir créé l'objet de classe Fichier CFvous pouvez ouvrir un fichier en appelant la méthodeOuvrir. La méthode doit préciser le chemin d'accès au fichier à ouvrir et le mode de son utilisation. Prototype de méthodeOuvrira la forme suivante :

Virtual BOOL Open (LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError=NULL);

En tant que paramètre lpszFileName, vous devez spécifier le nom du fichier à ouvrir. Vous pouvez spécifier uniquement le nom du fichier ou le nom complet du fichier qui inclut le chemin complet d'accès.

Le deuxième paramètre, nOpenFlags, spécifie l'action que la méthode Open effectue sur le fichier, ainsi que les attributs du fichier. Vous trouverez ci-dessous quelques valeurs possibles pour le paramètre nOpenFlags :

• CFile::modeCreate - Crée un nouveau fichier. Si le fichier spécifié existe, son contenu est effacé et la longueur du fichier est mise à zéro.
• CFile::modeNoTruncate - Ce fichier est destiné à être utilisé conjointement avec le fichier CFile::modeCreate. Si un fichier existant est créé, son contenu ne sera pas supprimé.

CFile :: modeRea d - Le fichier est ouvert en lecture seule.

CFile::modeReadWrite - Le fichier est ouvert en écriture et en lecture.

CFile::modeWrite - Le fichier est ouvert en écriture uniquement.

CFile::typeText - Utilisé par les classes dérivées de la classe CFile, telles que CStdioFile, pour travailler avec des fichiers en mode texte. Le mode texte convertit la combinaison d'un caractère de retour chariot et d'un caractère de saut de ligne.

CFile::Binary - Utilisé par les classes dérivées de la classe CFile, telles que CStdioFile, pour travailler avec des fichiers en mode binaire.

Paramètre facultatif pError, qui est un pointeur vers un objet de classe CFileException, n'est utilisé que si l'exécution d'une opération sur le fichier entraînerait une erreur. Dans ce cas, des informations supplémentaires seront écrites sur l'objet pointé par pError.

Méthode Ouvrirrenvoie une valeur différente de zéro si le fichier est ouvert et zéro en cas d'erreur. Une erreur lors de l'ouverture d'un fichier peut survenir, par exemple, si la méthode Open est spécifiée pour lire un fichier inexistant.

ID de fichier ouvert

La classe CFile comprend un élément de données m_hFile de type UINT. Il stocke l'identifiant du fichier ouvert. Si un objet de la classe CFile a déjà été créé, mais que le fichier n'a pas encore été ouvert, alors la constante hFileNull est écrite dans la variable m_hFile.

Généralement, l'identifiant du fichier ouvert n'est pas utilisé directement. Méthodes de classe Fichier CFvous permettent d'effectuer presque toutes les opérations avec des fichiers et ne vous obligent pas à spécifier un identifiant de fichier. Puisque m_hFile est un élément de classe, l'implémentation de ses méthodes y a toujours libre accès.

Fermeture des fichiers

Après avoir fini de travailler avec le fichier, celui-ci doit être fermé. Classe Fichier CFa une méthode Close spéciale pour cela. A noter que si un objet de la classe CFile a été créé et qu'un fichier a été ouvert, puis que l'objet est supprimé, le fichier associé est fermé automatiquement à l'aide d'un destructeur.

Lire et écrire des fichiers

Il existe plusieurs méthodes de classe pour accéder aux fichiers. Fichier CF: Lire, LireÉnorme, Écrire, ÉcrireÉnorme, Flush. Méthodes Lire et lireénorme sont conçus pour lire les données d’un fichier précédemment ouvert. Sur les systèmes d'exploitation 32 bits, les deux méthodes peuvent lire simultanément plus de 65 535 octets à partir d'un fichier. La spécification ReadHuge est considérée comme obsolète et n'est conservée que pour des raisons de compatibilité avec les systèmes d'exploitation 16 bits.

Les données lues à partir du fichier sont écrites dans le tampon lpBuf. Le paramètre nCount spécifie le nombre d'octets à lire dans le fichier. En fait, moins d'octets peuvent être lus dans le fichier que ce qui est demandé par le paramètre nCount. Cela se produit si la fin du fichier est atteinte pendant la lecture. Les méthodes renvoient le nombre d'octets lus dans le fichier.

Les méthodes Write et WriteHuge sont destinées à écrire dans un fichier. Sur les systèmes d'exploitation 32 bits, les deux méthodes peuvent écrire simultanément plus de 65 535 octets dans un fichier. Les méthodes écrivent les octets du tampon lpBuf dans le fichier ouvert nCount. Si une erreur d'écriture se produit, telle qu'un disque plein, les méthodes appellent à la gestion des exceptions.

Méthode de rinçage

Lorsque la méthode Write ou WriteHuge est utilisée pour écrire des données sur le disque, celles-ci peuvent rester dans un tampon temporaire pendant un certain temps. Pour vous assurer que les modifications nécessaires sont apportées au fichier sur le disque, vous devez utiliser la méthode Flush.

Opérations sur les fichiers

La classe comprend des méthodes qui vous permettent d'effectuer diverses opérations sur des fichiers, telles que copier, renommer, supprimer, modifier des attributs.

Pour changer le nom du fichier, la classe CFile inclut une méthode statique Rebaptiser, qui remplit les fonctions de cette commande. La méthode ne peut pas être utilisée pour renommer des répertoires. Si une erreur se produit, la méthode génère une exception.

Une méthode statique est incluse dans la classe CFile pour supprimer des fichiers Retirer, qui vous permet de supprimer le fichier spécifié. Cette méthode ne vous permet pas de supprimer des répertoires. Si le fichier ne peut pas être supprimé, la méthode lève une exception.

Pour déterminer la date et l'heure de création du fichier, sa longueur et ses attributs, une méthode statique est utilisée Obtenir le statut. Il existe deux variétés de méthodes : la première est définie comme une méthode virtuelle et la seconde est définie comme une méthode statique.

Version virtuelle de la méthode Obtenir le statutdétermine l'état ouvert du fichier associé à cet objet de classe CFile. Cette méthode est appelée uniquement lorsqu'un objet de classe CFile est créé et que le fichier est ouvert.

Version statique de la méthode Obtenir le statutpermet de déterminer les caractéristiques d'un fichier qui n'est pas associé à un objet de la classe CFile. Pour utiliser cette méthode, il n’est pas nécessaire d’ouvrir au préalable le fichier.

Verrouillage

La classe comprend des méthodes Plage de verrouillage Et Plage de déverrouillage, qui permettent de verrouiller un ou plusieurs éléments de données de fichiers pour permettre l'accès à d'autres processus. Si une application tente de reverrouiller des données précédemment verrouillées par cette application ou une autre, une exception est levée. Le verrouillage est l'un des mécanismes qui permettent à plusieurs applications ou processus de travailler simultanément sur le même fichier sans interférer les uns avec les autres.

Vous pouvez définir un verrou en utilisant la méthode Plage de verrouillage. Pour supprimer les verrous installés, vous devez utiliser la méthodePlage de déverrouillage. Si plusieurs verrous sont définis dans un fichier, chacun d'eux doit être libéré par un appel de méthode distinctPlage de déverrouillage.

Positionnement

Pour déplacer le pointeur de position actuelle du fichier vers une nouvelle position, vous pouvez utiliser l'une des méthodes de classe suivantes Fichier CF - Chercher, chercher à commencer, chercher à finir.À la classe Fichier CFcomprend également des méthodes qui vous permettent de définir et de modifier la longueur du fichier, -ObtenirLongueur, DéfinirLongueur.

Lors de l'ouverture d'un fichier, l'indicateur de position actuelle du fichier est situé au tout début du fichier. Lorsqu'une donnée est lue ou écrite, le pointeur de position actuelle se déplace vers la fin du fichier et pointe vers les données qui seront lues ou écrites lors de la prochaine opération de lecture ou d'écriture dans le fichier.

Pour déplacer le pointeur de position actuelle du fichier vers n’importe quel emplacement, vous pouvez utiliser la méthode universelle

Chercher. Il vous permet de déplacer le pointeur d'un certain nombre d'octets par rapport à la position de début, de fin ou actuelle du pointeur.

Pour déplacer le pointeur vers le début ou la fin d'un fichier, il est plus pratique d'utiliser des méthodes spéciales. Méthode

Chercher à commencerdéplace le pointeur au début du fichier et la méthodeRechercher jusqu'à la fin- jusqu'à sa fin.

Mais pour déterminer la longueur d’un fichier ouvert, il n’est pas nécessaire de déplacer son pointeur. Vous pouvez utiliser la méthode

ObtenirLongueur. Cette méthode renvoie également la longueur du fichier ouvert en octets. MéthodeDéfinir la longueurvous permet de modifier la longueur du fichier ouvert. Si cette méthode augmente la taille du fichier, la valeur des derniers octets n'est pas définie.

La position actuelle du pointeur de fichier peut être déterminée à l'aide de la méthode

ObtenirPosition. Renvoyé par méthodeObtenirPositionLa valeur 32 bits spécifie le décalage du pointeur depuis le début du fichier.

Caractéristiques des fichiers ouverts

Pour déterminer l'emplacement d'un fichier ouvert sur le disque, vous devez appeler la méthode ObtenirFilePath. Cette méthode renvoie un objet de la classeChaîneC, qui contient le chemin complet du fichier, y compris le nom du lecteur, les répertoires, le nom du fichier et l'extension du fichier.

Si vous avez uniquement besoin de déterminer le nom et l'extension d'un fichier ouvert, vous pouvez utiliser la méthode ObtenirNomFichier. Il renvoie un objet CString contenant le nom du fichier. Dans le cas où vous avez besoin de connaître uniquement le nom d'un fichier ouvert sans extension, utilisez la méthodeObtenirFileTitle.

La méthode suivante de la classe CFile vous permet de définir le chemin du fichier. Cette méthode ne crée, ne copie ni ne modifie le nom du fichier ; elle remplit uniquement l'élément de données correspondant dans l'objet de classe CFile.

Classe C

FichierMem

La bibliothèque MFC inclut la classe

Fichier CMem, hérité de la classe de baseFichier CF. Classe Fichier CMemreprésente un fichier situé dans la RAM. Avec des objets de classeFichier CMemla même chose qu'avec les objets de classeFichier CF. La différence est que le fichier associé à l'objetFichier CMem, ne se trouve pas sur le disque, mais dans la RAM de l'ordinateur. De ce fait, les opérations avec un tel fichier sont beaucoup plus rapides qu'avec des fichiers ordinaires.

Travailler avec des objets de classe

Fichier CMem, vous pouvez utiliser presque toutes les méthodes de la classeFichier CFqui ont été décrits ci-dessus. Vous pouvez écrire des données dans un tel fichier ou le lire. En plus de ces méthodes, la classe contientFichier CMemméthodes supplémentaires incluses.

Il existe deux constructeurs différents pour créer des objets de la classe CMemFile. Le premier constructeur CMemFile n'a qu'un seul paramètre facultatif nGrowBytes :

CMemFile(UINT nGrowBytes=1024);

Ce constructeur crée un fichier vide dans la RAM. Une fois créé, le fichier s'ouvre automatiquement (pas besoin d'appeler la méthode Ope

n).

Lorsque l'écriture dans un tel fichier commence, un bloc de mémoire est automatiquement alloué. Pour obtenir les méthodes de classe mémoire

Fichier CMemappeler des fonctions standardmalloc, réallocation Et gratuit. Si le bloc mémoire alloué n'est pas suffisant, sa taille est augmentée. Le bloc mémoire du fichier est augmenté en parties de nGrowBytes octets. Après avoir supprimé un objet de classeFichier CMemla mémoire utilisée est automatiquement renvoyée au système.

Le deuxième constructeur de la classe CMemFile possède un prototype plus complexe. Ce constructeur est utilisé dans les cas où le programmeur lui-même alloue de la mémoire pour le fichier :

CMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes=0);

Le paramètre lpBuffer spécifie le tampon à utiliser pour le fichier. La taille du tampon est déterminée par le paramètre nBufferSize.

Le paramètre facultatif nGrowBytes est utilisé de manière plus complète que dans le constructeur de première classe. Si nGrowBytes contient zéro, alors le fichier généré contiendra les données du lpBuffer. La longueur d'un tel fichier sera égale à nBufferSize.

Si nGrowBytes est supérieur à zéro, alors le contenu de lpBuffer est ignoré. De plus, si plus de données sont écrites dans un tel fichier que ne peut en contenir le tampon alloué, sa taille augmente automatiquement. Le bloc mémoire du fichier est augmenté en parties de nGrowBytes octets.

Fichier CMempermet d'obtenir un pointeur vers la zone mémoire utilisée par le fichier. Grâce à ce pointeur, vous pouvez travailler directement avec le contenu du fichier, sans vous limiter aux méthodes de classeFichier CF. Pour obtenir un pointeur vers un tampon de fichier, vous pouvez utiliser la méthode Detach. Avant de faire cela, il est utile de déterminer la longueur du fichier (et donc la taille du buffer mémoire) en appelant la méthodeObtenirLongueur. Détacherferme le fichier donné et renvoie un pointeur vers le bloc de mémoire qu'il utilise. Si vous devez à nouveau ouvrir le fichier et lui associer un bloc RAM, vous devez appeler la méthodeAttacher.

Il est à noter que pour gérer le buffer des fichiers, la classe

Fichier CMemappelle des fonctions standardsmalloc, réallocation Et gratuit. Par conséquent, afin de ne pas casser le mécanisme de gestion de la mémoire, le tampon lpBuffer doit être créé par les fonctionsmalloc ou calloc.

Classe CStdioFile

Ceux qui sont habitués à utiliser les fonctions d'E/S de streaming de la bibliothèque standard C et C++ doivent prêter attention à la classe

Fichier CStdio, hérité de la classe de baseFichier CF. Cette classe vous permet d'effectuer des E/S tamponnées en mode texte et binaire. Pour les objets de classeFichier CStdioVous pouvez appeler presque toutes les méthodes de la classe CFile.Fichier CStdioinclut l'élément de données m_pStream, qui contient un pointeur vers le fichier ouvert. Si un objet de classeFichier CStdiocréé, mais que le fichier n'est pas encore ouvert ou fermé, alors m_pStream contient la constante NULL.Fichier CStdioa trois constructeurs différents. Le premier constructeur de la classe CStdioFile n'a aucun paramètre. Ce constructeur crée uniquement un objet de classe, mais n'ouvre aucun fichier. Pour ouvrir un fichier, vous devez appeler la méthodeOuvrirclasse de baseFichier CF.

Constructeur de deuxième classe

Fichier CStdiopeut être appelé si le fichier est déjà ouvert et que vous devez créer un nouvel objet de la classe CStdioFile et lui associer le fichier ouvert. Ce constructeur peut être utilisé si le fichier a été ouvert avec une fonction standardfouvert. Le paramètre méthode doit contenir un pointeur vers le fichier obtenu en appelant la fonction standardfouvert.

Le troisième constructeur peut être utilisé si vous devez créer un objet de classe

Fichier CStdio, ouvrez un nouveau fichier et associez-le à l'objet nouvellement créé.

Pour lire et écrire dans un fichier texte, la classe CStdioFile inclut deux nouvelles méthodes :

Chaîne de lecture Et Chaîne d'écriture. La première méthode vous permet de lire une chaîne de caractères à partir d'un fichier et la seconde méthode vous permet de l'écrire.

Exemples d'écriture et de lecture à partir d'un fichier

Voici des fragments de code qui démontrent l'utilisation des panneaux de dialogue de sélection de fichier standard et la procédure de lecture et d'écriture dans un fichier.

Ouvrir un fichier et le lire

CString m_Text ; ……// création d'un panneau de sélection de fichier standard Ouvrir CFileDialog DlgOpen(TRUE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY,(LPCSTR)" Fichiers texte (*.txt) |*.txt||");// affiche le panneau de sélection de fichier standard Ouvrir if(DlgOpen.DoModal()==IDOK) (// crée un objet et ouvre le fichier en lecture CStdioFile File(DlgOpen.GetPathName(),CFile::modeRead|CFile::typeBinary);// lecture des chaînes du fichier CString& ref=m_Text; m_Texte)

Ouverture et écriture à partir d'un fichier

CString m_Text ; // création d'un panneau de sélection de fichier SaveAs standard CFileDialog DlgSaveAs(FALSE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, (LPCSTR)" Fichiers texte (*.txt) |*.txt||"); // affiche le panneau de sélection de fichier SaveAs standard if(DlgSaveAs.DoModal()==IDOK) ( // crée un objet et ouvre un fichier en écriture Fichier CStdioFile (DlgSaveAs.GetPathName(), CFile::modeCreate|CFile::modeWrite|CFile::typeBinary); // écriture dans un fichier de chaînes Fichier.WriteString((LPCTSTR)m_Text);

)

contient le code de travail du programme, conçu pour la simplicité en tant qu'application console sous MFC. Pour que le programme fonctionne, n'oubliez pas de procéder comme suit :