[fstream] Manipulation d'un fichier ...

Version imprimable

08/02/2006, 20h15
Zenol

[fstream] Manipulation d'un fichier ...

Bonjour,
J'aurais besoin d'un petu aide pour quelques manipulations avec un fichier :
1 - Comment lire dans un fstream ouvert en std::ios_base::in les "Size" caractères allent de "Start" a "Start+Size"?
2 - Comment suprimer tous les caractères dans un fichier de taille "Size" allent de "Start" à "Start+Size"?
3 - Comment rempalcer dans un fichier avec toujours Size et Start, les caractères par une chaine qui peut être plus longue ou plus courte que celle de départ.(Taille diférente que Size)?

Merci d'avence.
09/02/2006, 08h45
Caine

Bonjour,

Tu as jeté un oeil http://c.developpez.com/faq/cpp/?page=fichiers ?

1/ Tu calcules la taille du fichier, puis tu lis "Size" données.
2/ Tu fais un "fillmemory" avec '\0' et tu écrases le fichier. Impossible sans un autre droit que ::in sur le fichier je pense.
3/ Comme en 2 pour les droits. Ici, ::app semble plus indiqué.

Par contre je n'ai jamais testé avec la classe de base fstream.
09/02/2006, 08h47
Jan Rendek

1/ seekg et tellg, membres de la classe istream permettent de naviguer dans le flux
2/ A priori, il faut recréer un autre fichier ne contenant plus ces caractères.
Le plus simple est de passer par un temporaire et de le renommer ensuite
3/ idem
09/02/2006, 19h40
Zenol

Citation:

Envoyé par Caine

Tu as jeté un oeil http://c.developpez.com/faq/cpp/?page=fichiers ?

Oui, et j'y retourne a chaque fois que j'utilise des fichiers.
Mes question était plutot de savoir si std::fstream permêtait de faire cela en gérent les entrées + sorties en même temp...(Ce qui n'est pas le cas).
Donc, j'ai réussi a :
-Lire la partie que je veut dnas mon fichier
Et je suis sur le point de :
-Suprimer une partie
-Remplacer une partie

Sa risque d'être dificile car enfaite je tente d'écrire un dll pour gèrer un fichier qui fonctionera comme des archives(style les .rar, .zip, .jar)
Donc il faut que je charge la liste des fichiers en entète, que je récupère la taille des fichiers ect.

Je vais donc réécrire le fichier pour la supression, et pareille pour le remplacement.(En fait je croi que je ferait supression+ajout. Apprès tout le remplacement/ajout est très rare. Si on le fait une fois, le fichier sera récupèrer bien plus souvent.)

Par ontre, j'aimerais savoir comment fonctione getline.
Je penssait qu'utiliser getline décaler le pointeur a l'intérieur du flux, et alors qu'un tellg me doneraitt la position apprès le getline.
Erreur de ma part, biensur. J'utilise donc un Position += Buffer.size() + 1; ou Buffer est la chaine récupèrer avec getline.
10/02/2006, 23h21
Zenol

Voila, je progresse dans la programmation de la class, exepter que j'ai un petit problème :
Quand j'ai mes deux fonctions Init et Read utilisant chacune un flux ifstream séparer, créer et détruit dans chacune de ces fonctions, tout fonctione.
Par contre, si je change trois lignes, en rajoutant dans mon header std::ifstream File et dans mon .cpp en remplacent les deux std::ifstream File(... par File.open(... plus rien ne s'afiche -> plus rien n'est récupèrer dans mon fichier.
10/02/2006, 23h34
ChriGoLioNaDor

Tu pourrais poster tes portions de code SVP? ca serait plus parlant ;)

Ben en faite ... Bon d'accord.
Voila :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
//DCF.cpp
#include "DCF.h"
 
//Constructeurs
DCF::DCF(const char* file)
{
    //Nom du fichier
    FileName = file;
    Init();
}
void DCF::Init()
{
    //Supression de la liste des fichiers
    ListFile.clear();
    //Flux vers le fichier
    std::ifstream File(FileName.c_str());
    FileStart = 0;
    //Chargement de la liste des fichiers
    std::string Buffer;
    long laststart = 0;
    while(getline(File, Buffer, '\255'))
    {
      //Vérification de chaine "valide"
      if(Buffer.find('\001') == -1)
        break;
      //Position de départ
      FileStart += Buffer.size()+1;
      //Ajout du nouveau fichier a la liste
      StSi Location;
      std::string filename;
      filename = Buffer.substr(0, Buffer.find('\001'));
      Location.Size = std::from_string<long>(Buffer.substr(Buffer.find('\001')+1, Buffer.size()-Buffer.find('\001')+1));
      Location.Start = laststart;
      laststart += Location.Size;
      ListFile[filename] = Location;
    }
    File.close();
}
//Destructeur
DCF::~DCF()
{
}
 
//Write
void DCF::Write(const char* name, std::string Content)
{
    //Supression si le fichier existe déja
    if(ListFile.find(name) != ListFile.end())
      Delete(name);
    //Chargement du fichier
    if(!Content.size())
      return;
    //Variable temporaire de sauvegarde
    char *content;
    //Sauvegarde du contenu
    {
      std::ifstream File(FileName.c_str());
      File.seekg(FileStart);
      long Width = std::size<long>(File)-FileStart;
      content = new char[Width+1];
      File.read(content, Width);
      content[Width] = '\0';
      File.close();
    }
    //Ecriture de la table
    {
      std::ofstream Out(FileName.c_str());
      for(TListFile::iterator i = ListFile.begin(); i != ListFile.end(); i++)
	    Out << i->first << '\001' << i->second.Size << '\255';
      Out << name << '\001' << Content.size() << '\255';
      Out << content;
      Out << Content;
    }
    //Supression de la variable temporaire
    delete [] content;
    //Re-Initialisation
    Init();
}
 
void DCF::Write(const char* file)
{
    //Supression si le fichier existe déja
    if(ListFile.find(file) != ListFile.end())
      Delete(file);
    //Chargement du fichier
    std::ifstream Load(file);
    if(!Load || !std::size<long>(Load))
      return;
    //Variable temporaire de sauvegarde
    char *content;
    //Sauvegarde du contenu
    {
      std::ifstream File(FileName.c_str());
      File.seekg(FileStart);
      long Width = std::size<long>(File)-FileStart;
      content = new char[Width+1];
      File.read(content, Width);
      content[Width] = '\0';
      File.close();
    }
    //Ecriture de la table
    {
      std::ofstream Out(FileName.c_str());
      for(TListFile::iterator i = ListFile.begin(); i != ListFile.end(); i++)
	    Out << i->first << '\001' << i->second.Size << '\255';
      Out << file << '\001' << std::size<long>(Load) << '\255';
      Out << content;
      Out << Load.rdbuf();
    }
    Load.close();
    //Supression de la variable temporaire
    delete [] content;
    //Re-Initialisation
    Init();
}
 
//Read
std::string DCF::Read(const char* file)
{
    //Exclusion des fichiers inexistants
    if(ListFile.find(file) == ListFile.end())
      return "";
    //Chargement des Size premier caractères
    std::ifstream File(FileName.c_str());
    File.seekg(FileStart + ListFile[file].Start);
    char *content = new char[ListFile[file].Size+1];
    File.read(content, ListFile[file].Size);
    content[ListFile[file].Size] = '\0';
    std::string FContent(content);
    delete[] content;
    //Fermeture
    File.close();
    return FContent;
}
 
//Delete
void DCF::Delete(const char* file)
{
    //Verification de l'existance
    if(ListFile.find(file) == ListFile.end())
      return;
    //Chargement du fichier
    std::string Buffer;
    {
      std::ifstream Load(FileName.c_str());
      std::stringstream Convert;
      Convert << Load.rdbuf();
      Buffer = Convert.str();
      Load.close();
    }
    Buffer = Buffer.substr(FileStart);
    //Supression des données
std::cout << "Supression_Buffer = " << Buffer << '\n';
    Buffer = Buffer.substr(0, ListFile[file].Start) + Buffer.substr(ListFile[file].Start+ListFile[file].Size);
std::cout << "Supression_Buffer = " << Buffer << '\n';
    //Supression de la clef
    ListFile.erase(ListFile.find(file));
    //Ecriture de la table
    {
      std::ofstream Out(FileName.c_str());
      for(TListFile::iterator i = ListFile.begin(); i != ListFile.end(); i++)
	    Out << i->first << '\001' << i->second.Size << '\255';
      Out << Buffer;
    }
    //Re-Initialisation
    Init();
}
//DCF.h
#ifndef SDL_TEXTURE_H
  #define SDL_TEXTURE_H
  #ifndef DLL_Act
    #ifdef BUILD_DLL
      #define DLL_ACT __declspec(dllexport)
    #else
      #define DLL_ACT __declspec(dllimport)
    #endif
  #endif
  //Fonctions costum pour taille d'un fichier, convertion des chaines de caractères...
  #include "Cstring.h"
  #include "Cfile.h"
  //STL
  #include <sstream>
  #include <fstream>
  #include <map>
  #include <iostream>
  class DLL_ACT DCF
  {
    public:
      DCF(const char* file);
      ~DCF();
 
      void Init();
 
      void        Write (const char* file);
      void        Write (const char* name, std::string Content);
      std::string Read  (const char* file);
      void        Delete(const char* file);
    //private:
      struct StSi
      {
          long Start;
          long Size;
      };
      typedef std::map<std::string, StSi> TListFile;
      TListFile ListFile;
      std::string FileName;
      long FileStart;
  };
#endif

Si je met std::ifstream File en memebre, et que je remplace tout les constructeurs en open(, sa ne fonctione plus.(Chaine vide retourner par read)
Sinon, problème qui n'a rien avoir avec les gestion des fichiers, c'est le classement de std::map, mais pour sa je fait un autre sujet.