fstream : impossible d'écrire après avoir lu ?

Version imprimable

Bonjour,
je suis confronté à un petit soucis :
Je créé une classe pour gérer des petits fichiers de configuration. Ces fichiers sont présentés ainsi :

Code:

1
2
3
4
5
 
[bloc1]
valeur1=blabla;
valeur2=blablabla;
...

Je code actuellement une fonction qui écrit un nouveau bloc (entre les crochets) dans le fichier. J'ai donc pris le soin d'ouvrir le fichier en mode lecture et écriture (avec un objet de type fstream).
Mais, je rencontre un problème que je trouve incompréhensible. Dès que je décide d'écrire quelque chose dans le fichier, il y a deux cas de figures :

- Ou bien j'ai déjà lu quelque chose dans le fichier (à l'aide de la méthode 'get' ou '<<'), auquel cas il est impossible d'écrire quelque chose dans le fichier sans le recharger (close puis open) ;
- Ou alors je n'ai pas encore lu dans le fichier et je peux écrire sans problème dedans.

Maintenant, ce que je trouve étrange, c'est que dans l'autre sens ça marche sans problèmes : je peux d'abords écrire quelque chose, puis lire sans problème.

Voilà mon code :

timFile.cpp

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
210
211
212
213
214
215
216
217
218
219
220
221
 
#include "timFile.h"
 
timFile::timFile() {
   m_s_path_file.clear();
}
 
timFile::timFile(std::string path_file) {
   m_s_path_file = path_file;
}
 
timFile::~timFile() {
   if(m_file.is_open()) {
      m_file.close();
   }
}
 
bool timFile::open() {
   // On regarde si l'utilisateur a spécifié un fichier à ouvrir
   if(m_s_path_file.empty()) {
      return false;
   }
   // On regarde si le fichier est déjà ouvert en lecture
   if(m_file.is_open()) {
      return false;
   }
   // Sinon, on ouvre le fichier
   else {
      m_file.open(m_s_path_file.c_str(), 
                  std::ios::in | std::ios::out | std::ios::ate);
   }
   // On teste si le fichier a bien été ouvert
   if(m_file == NULL) {
      return false;
   }
 
   return true;
}
 
void timFile::close() {
   m_file.close();
}
 
bool timFile::is_bloc(std::string name) {
   char carac;
   std::string s_string;
 
   // Remise à 0 du curseur
   m_file.seekg(0, std::ios::beg);
 
   // On teste si le fichier a d'abord été ouvert
   if(!m_file.is_open()) {
      return false;
   }
 
   while(m_file.get(carac)) {
      // On regarde si la ligne est un commentaire
      if(carac == '#') {
         // Si oui, alors on la saute
         while(m_file.get(carac)) {
            if(carac == '\n') {
               break;
            }
         }
      }
      if(carac == '[') {
         s_string.clear();
         while(m_file.get(carac)) {
            if(carac != ']' && carac != EOF && carac != '\n') {
               s_string += carac;
            }
            else {
               break;
            }
         }
      }
      // On compare ensuite la chaine obtenue avec le nom de bloc à trouver
      if(name.compare(s_string) == 0) {
         return true;
      }
   }
 
   return false;
}
 
bool timFile::is_value(std::string bloc, std::string value) {
   char carac;
   std::string s_string;
 
   // On teste si le fichier a d'abord été ouvert
   if(!m_file.is_open()) {
      return false;
   }
 
   // On teste si le bloc existe
   if(!is_bloc(bloc)) {
      return false;
   }
 
   // On cherche dans le bloc jusqu'à ce qu'on trouve la valeur sélectionnée
   while(m_file.get(carac)) {
      // Tant qu'on ne rencontre pas l'opérateur d'assignation
      if(carac != '=' && carac != ' ' && carac != '\n') {
         s_string += carac;
      }
      // Sinon, on vérifie si on a trouvé la bonne valeur puis on saute la ligne
      // si ce n'est pas elle
      else if(carac == '=') {
         if(s_string.compare(value) == 0) {
            return true;
         }
         s_string.clear();
         while(m_file.get(carac)) {
            if(carac == ';') {
               break;
            }
         }
      }
   }
 
   return false;
}
 
std::string timFile::get_value(std::string bloc_name, std::string value_name) {
   char carac;
   std::string s_string;
   if(!is_value(bloc_name, value_name)) {
      return "-1";
   }
 
   s_string.clear();
   while(m_file.get(carac)) {
      if(carac != ';') {
         s_string += carac;
      }
      else {
         break;
      }
   }
 
   return s_string;
}
 
std::string* timFile::get_avalue(std::string bloc_name, std::string value_name) {
   int pos_cursor = 0;
   int nb_value = 0;
   int i = 0;
   char carac;
   std::string* a_s_string;
 
   // On vérifie que la valeur existe
   if(!is_value(bloc_name, value_name)) {
      return NULL;
   }
 
   // On enregsitre la position du curseur
   pos_cursor = m_file.tellg();
 
   // On compte le nombre de valeurs à placer dans le tableau
   while(m_file.get(carac)) {
      if(carac == '|') {
         nb_value++;
      }
      if(carac == ';') {
         nb_value++;
         break;
      }
   }
 
   // On alloue le tableau
   a_s_string = new std::string[nb_value + 1];
 
   // On repositionne le curseur
   m_file.seekg(pos_cursor, std::ios::beg);
 
   // On met les valeurs dans le tableau
   while(m_file.get(carac)) {
      if(carac != '|' && carac != ';') {
         a_s_string[i] += carac;
      }
      else if(carac == '|'){
         i++;
      }
      else {
         break;
      }
   }
 
   a_s_string[i + 1] = "END";
 
   return a_s_string;
}
 
bool timFile::set_bloc(std::string bloc) {
   std::string s_string;
   s_string.clear();
 
   // On vérifie que le bloc n'existe pas déjà
   if(is_bloc(bloc)) {
      return false;
   }
 
   m_file.close();
   m_file.open(m_s_path_file.c_str(), 
               std::ios::in | std::ios::out | std::ios::ate);
 
   // On créé la chaine
   s_string += '[';
   s_string += bloc;
   s_string += ']';
 
   // On se place à la fin du fichier
   m_file.seekp(0, std::ios::end);
 
   // On écrit la chaine dans le fichier
   if(m_file << s_string) {
      return true;
   }
 
   return false;
}

timFile.h

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
 
#ifndef _TIMFILE_
#define _TIMFILE_
 
#include <iostream>
#include <fstream>
 
class timFile {
   std::fstream   m_file;
   std::string    m_s_path_file;
public:
   // Constructeurs
   timFile();
   timFile(std::string path_file);
 
   // Destructeur
   ~timFile();
 
   // Accesseurs
   std::string get_path_file() const { return m_s_path_file; }
 
   // Mutateurs
   void  set_path_file(std::string s_path_file) {
      m_s_path_file = s_path_file;
   }
 
   // Méthodes
   bool open();
   void close();
   // Action(s) en lecture
   bool is_bloc(std::string name);
   bool is_value(std::string bloc, std::string value);
   std::string get_value(std::string bloc_name, std::string value_name);
   std::string* get_avalue(std::string bloc_name, std::string value_name);
   // Action(s) en écriture
   bool set_bloc(std::string bloc);
};
 
#endif

J'ai conscience que ce code n'est pas encore aboutit, mais ça n'est pas mon intérêt pour le moment. J'aimerais juste comprendre d'où viens ce soucis...
Merci !

09/08/2010, 00h27
koala01

Salut,

De manière générale, il est rarement opportun de vouloir manipuler un fstream, ne serait-ce que parce que tu... ne mélangera jamais les périodes de lecture et d'écriture.

En effet, soit tu ouvres un fichier en lecture et tu en lis tout ou partie du contenu, soit tu ouvres celui-ci en écriture, et tu écrit des informations dedans, éventuellement après son contenu. Mais il n'y a strictement aucun sens à vouloir lire une partie avant d'écrire une autre, pour terminer par en lire une troisième, pas plus qu'il n'y a de sens à vouloir écrire des informations avant d'en lire d'autre pour terminer en... en écrivant une partie supplémentaire.

Il faut d'ailleurs se rappeler qu'une fois qu'une information est écrite dans un fichier, elle est "gravée dans le marbre", car il est impossible de la modifier sans... "casser le moule" et tout réécrire.

Et c'est surtout vrai pour les fichiers "textes".

Il faut en effet se rendre compte que, dés que tu veux transformer un no en yes, un on en off ou un 1 en 10 (ou inversement), tu dois décaler... l'ensemble de ce qui suit la valeur que tu veux modifier.

De plus, il faut te dire que, dans le cas d'un fichier de configuration, le fichier est destiné à être lu en intégralité au lancement du programme et à être écrit (toujours en intégralité) "sur demande", mais au plus tard à la fermeture du programme, et qu'il y a tout intérêt à ce que le fichier soi... fermé entre ces deux étapes: il ne sert, en général, à rien de monopoliser des ressources plus que nécessaire, et c'est sans doute encore plus vrai pour ce qui est des fichiers ;)

C'est pour cela que tu peux, effectivement, créer une classe qui s'occupera de sauvegarder et de charger les options de configuration, mais qu'il est préférable d'ouvrir le fichier en lecture lorsque tu souhaite charger la configuration, et de l'ouvrir en écriture quand... tu souhaite l'enregistrer.

L'idéal étant d'ailleurs de ne maintenir qu'une chaine de caractères identifiant le fichier dans la classe et de ne créer l'instance du fichier que... dans la fonction qui en a besoin (un ifstream pour la fonction de lecture et un ofstream pour la fonction d'écriture) ;)

Ceci dit, il pourrait être intéressant pour toi de regarder un peu du coté de boost.program_options... C'est une bibliothèque prévue, justement, pour gérer les différentes options de configuration des applications ;)
09/08/2010, 02h48
yetimothee

Merci pour ta réponse. Je pensais bien que l'utilisation de fstream posait certains problèmes, mais à ce point, c'est plutôt ennuyeux.
Est-ce que l'utilisation d'une liste ou d'un vecteur de char peut être une solution performante ? Ou cela demande t-il peut-être trop de ressources ?

Je fais cela uniquement parce que j'en éprouve du plaisir, je n'ai pas envie d'utiliser quelque chose de déjà existant. Déjà, je trouve que l'utilisation de la STL c'est de la triche (un jour, je vais devoir réécrire tout ça à ma façon, juste pour me prouver que je mérite de l'utiliser :roll:)
09/08/2010, 09h18
koala01

Citation:

Envoyé par yetimothee

Merci pour ta réponse. Je pensais bien que l'utilisation de fstream posait certains problèmes, mais à ce point, c'est plutôt ennuyeux.

Il faut comprendre que, les fichiers, c'est la seule chose qui subsiste ( à part quelques données dans des ROM) quand on coupe le courent... Cela se doit donc d'être... le moins volatile possible :D

Citation:

Est-ce que l'utilisation d'une liste ou d'un vecteur de char peut être une solution performante ?

Une solution performante à quoi :question:

Pour assurer la persistance de ta configuration, il n'y a rien à faire: tu dois recourir à un fichier, autrement, tu sera bon pour... reconfigurer ton application à chaque fois :aie:

Pour gérer les informations de configuration, il est préférable de mettre en place une ou plusieurs structures qui... te permettront de manipuler ces informations et d'y accéder "là où tu en a besoin"

Citation:

Je fais cela uniquement parce que j'en éprouve du plaisir, je n'ai pas envie d'utiliser quelque chose de déjà existant.

Si tu tiens à refaire (seul) ce que d'autres ont déjà fait en équipe sans doute bien mieux que toi, c'est ton droit... Mais ne crois tu pas que c'est perdre ton temps sur des détails alors que tu as surement beaucoup plus intéressant à faire au niveau de l'application même :question

Citation:

Déjà, je trouve que l'utilisation de la STL c'est de la triche (un jour, je vais devoir réécrire tout ça à ma façon, juste pour me prouver que je mérite de l'utiliser :roll:)

Il ne faut pas voir les choses sous cet angle, bien loin de là...

C++ est un langage complexe qui permet de se tirer une "balle dans le pied" excessivement facilement.

La STL et certaines bibliothèques que l'on propose à longueur d'années (comme boost) sont des outils stables qui te permettent, justement, d'éviter une partie des problèmes auxquels il n'est gai de se frotter qu'une seule fois, et qui permettent d'apporter une sécurité certaine à ton programme.

C'est comme si tu me disais que tu préfère creuser un trou à mains nues ou allumer un feu avec deux bâtons plutôt que d'utiliser une pelle ou un briquet, parce que, sinon, "c'est trop facile".

Tu peux me croire sur parole: tu auras déjà bien assez de problèmes à résoudre sans, en plus, vouloir en résoudre certains qui ont déjà été correctement résolus par d'autre. L'utilisation de la STL, par exemple, te permet au mieux de te concentrer sur les problèmes qui sont réellement tiens, et tu ne tardera pas à te rendre compte qu'ils sont déjà nombreux dés que tu pars sur un projet un temps soit peu important ;)

Maintenant, l'idée d'implémenter soi même quelque chose de proche de la STL est quelque chose qui peut s'avérer intéressant pour "aller au fond des choses", mais c'est, en soi, un projet d'envergure qui ne vaut la peine que... si tu as vraiment du temps à perdre ;)
09/08/2010, 14h12
yetimothee

Je ne suis fondamentalement pas contre l'utilisation de la STL ni de Boost, ce que je dis, c'est juste que j'y gagnerais sans doute beaucoup à comprendre ce que j'utilise plutôt que juste l'utiliser (d'un point de vue pédagogique). C'est comme les maths, il est souvent très intéressant de démontrer des choses que l'on admet...
Néanmoins, je ne compte pas refuser l'utilisation de la STL, ça serait, comme tu dis, se tirer une balle dans le pied ^^

Pour ce qui est des listes ou des vectors, je me suis sans doute mal exprimé :
Je charge le fichier dans une liste au lancement du programme (enfin quand je le demande), puis je le modifie à partir de là. A chaque rajout de choses dans la liste, je met à jour le fichier.
Maintenant, ce que je me demande, c'est si les listes ou les vectors offrent des performances en lecture et écriture suffisantes vis-à-vis d'un fichier en lecture ou en écriture ? Par exemple, est-ce que le temps de parcourir tout le fichier avec l'objet ifstream est aussi rapide que parcourir une liste contenant autant de données que le fichier ?

Merci pour vos réponses.
09/08/2010, 14h54
white_tentacle

Une liste en mémoire est très très nettement plus rapide qu'un fichier. En terme de performance, on a généralement

réseau << fichier local << mémoire.

Cela dit, les réseaux ont fait de gros progrès et pour du réseau local ça peut être aussi rapide qu'un fichier local. Mais la RAM reste par contre très largement plus rapide qu'un fichier (un fichier sur disque, c'est très lent à l'échelle d'un ordinateur moderne).

Merci,
donc j'y gagnerais avec l'utilisation d'une liste... Merci beaucoup !

Edit :
Voilà mon nouveau code :

timFile.h

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
 
#ifndef _TIMFILE_
#define _TIMFILE_
 
#include <iostream>
#include <fstream>
#include <list>
 
class timFile {
   std::list<char>            m_l_content;
   std::list<char>::iterator  m_icursor;
   std::list<char>::iterator  m_ocursor;
   std::string                m_s_path_file;
public:
   // Constructeurs
   timFile();
   timFile(std::string path_file);
 
   // Destructeur
   ~timFile();
 
   // Accesseurs
   std::string get_path_file() const { return m_s_path_file; }
 
   // Mutateurs
   void  set_path_file(std::string s_path_file) {
      m_s_path_file = s_path_file;
   }
 
   // Méthodes
   bool load();
   bool write();
   void view();
   // Action(s) en lecture
   bool is_bloc(std::string name);
   bool is_value(std::string bloc, std::string value);
   std::string get_value(std::string bloc_name, std::string value_name);
   std::string* get_avalue(std::string bloc_name, std::string value_name);
   // Action(s) en écriture
   bool set_bloc(std::string bloc);
   bool set_value(std::string bloc, std::string value, std::string vvalue);
};
 
#endif

timFile.cpp

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
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
 
#include "timFile.h"
 
 
// Constructeur(s)
timFile::timFile() {
   m_s_path_file.clear();
   m_icursor = m_ocursor = m_l_content.begin();
}
 
timFile::timFile(std::string path_file) {
   m_s_path_file = path_file;
   m_icursor = m_ocursor = m_l_content.begin();
}
 
 
// Destructeur
timFile::~timFile() {
   write();
   m_l_content.clear();
}
 
// Charge le fichier dans une liste de char
bool timFile::load() {
   char carac;
   std::ifstream file;
   file.open(m_s_path_file.c_str(), std::ios::in);
 
   if(!file.is_open()) {
      return false;
   }
 
   while(file.get(carac)) {
      m_l_content.push_back(carac);
   }
 
   file.close();
 
   return true;
}
 
// Affiche le contenu du fichier
void timFile::view() {
   m_icursor = m_l_content.begin();
   while(m_icursor != m_l_content.end()) {
      std::cout << *m_icursor;
      m_icursor++;
   }
}
 
// Ecrit la liste de char dans le fichier
bool timFile::write() {
   std::ofstream file;
   file.open(m_s_path_file.c_str(), std::ios::out | std::ios::trunc);
 
   if(!file.is_open()) {
      return false;
   }
 
   m_ocursor = m_l_content.begin();
   while(m_ocursor != m_l_content.end()) {
      file.put(*m_ocursor);
      m_ocursor++;
   }
 
   file.close();
 
   return true;
}
 
// Vérifie l'existence du bloc spécifié
bool timFile::is_bloc(std::string name) {
   std::string s_string;
 
   m_icursor = m_l_content.begin();
   while(m_icursor != m_l_content.end()) {
      // On récupère le nom du bloc
      if(*m_icursor == '[') {
         s_string.clear();
         while(*m_icursor != ']') {
            if(*m_icursor != '[') {
               s_string += *m_icursor;
            }
            m_icursor++;
         }
         m_icursor++;
      }
      // On compare ce nom au nom spécifié par l'utilisateur
      if(s_string.compare(name) == 0) {
         return true;
      }
      m_icursor++;
   }
 
   return false;
}
 
// Vérifie l'existence de la valeur spécifiée dans le bloc spécifié
bool timFile::is_value(std::string bloc, std::string value) {
   std::string s_string;
   s_string.clear();
 
   if(!is_bloc(bloc)) {
      return false;
   }
 
   // On regarde dans le bloc jusqu'à voir la fin du fichier ou le début 
   // d'un nouveau bloc
   while(m_icursor != m_l_content.end() && *m_icursor != '[') {
      // Tant qu'on regarde le nom de la valeur, on la récupère
      if(*m_icursor != '\n' && *m_icursor != '=') {
         s_string += *m_icursor;
      }
      // On compare ensuite la valeur trouvée à celle spécifiée
      if(s_string.compare(value) == 0) {
         return true;
      }
      // On saute la ligne
      if(*m_icursor == '=') {
         s_string.clear();
         while(*m_icursor != ';') {
            m_icursor++;
         }
      }
      m_icursor++;
   }
 
   return false;
}
 
// Récupère la valeur de la valeur spcifiée dans le bloc spécifié
std::string timFile::get_value(std::string bloc_name, std::string value_name) {
   std::string s_string;
   s_string.clear();
 
   if(!is_value(bloc_name, value_name)) {
      return s_string;
   }
 
   while(*m_icursor != '=') {
      m_icursor++;
   }
 
   while(*m_icursor != ';' && *m_icursor != '\n' 
         && m_icursor != m_l_content.end()) {
      if(*m_icursor != '=') {
         s_string += *m_icursor;
      }
      m_icursor++;
   }
 
   return s_string;
}
 
// Récupère un tableau de str de la valeur du bloc spécifié
std::string* timFile::get_avalue(std::string bloc_name, std::string value_name){
   int nb_value = 0;
   std::list<char>::iterator cursor;
   int i = 0;
   std::string *a_s_string;
 
   if(!is_value(bloc_name, value_name)) {
      return NULL;
   }
 
   while(*m_icursor != '=') {
      m_icursor++;
   }
 
   m_icursor++;
   cursor = m_icursor;
 
   while(*m_icursor != ';' && *m_icursor != '\n' 
         && m_icursor != m_l_content.end()) {
      if(*m_icursor == '|') {
         nb_value++;
      }
      m_icursor++;
   }
 
   a_s_string = new std::string[nb_value + 2];
   m_icursor = cursor;
 
   while(*m_icursor != ';' && *m_icursor != '\n' 
         && m_icursor != m_l_content.end()) {
      if(*m_icursor != '|') {
         a_s_string[i] += *m_icursor;
      }
      else {
         i++;
      }
      m_icursor++;
   }
 
   a_s_string[i + 1] += "END";
 
   return a_s_string;
}
 
// Ajoute le bloc spécifié dans la liste
bool timFile::set_bloc(std::string bloc) {
   int i = 0;
   const char *s_string = bloc.c_str();
   // Si le bloc existe déjà
   if(is_bloc(bloc)) {
      return false;
   }
 
   // Sinon, on ajoute le bloc à la fin du fichier
   m_l_content.push_back('\n');
   m_l_content.push_back('[');
   while(s_string[i] != '\0') {
      m_l_content.push_back(s_string[i]);
      i++;
   }
   m_l_content.push_back(']');
 
   if(write()) {
      return true;
   }
 
   return false;
}
 
// Ajoute la valeur spécifié dans le bloc spécifié de la liste
bool timFile::set_value(std::string bloc, std::string value, 
                        std::string vvalue) {
   int i = 0;
   const char* s_value = value.c_str();
   const char* s_vvalue = vvalue.c_str();
   std::list<char>::iterator cursor;
 
   // On vérifie que le bloc spécifié existe
   if(!is_bloc(bloc)) {
      if(!set_bloc(bloc)) {
         return false;
      }
   }
 
   cursor = m_icursor;
 
   // On vérifie que la valeur spécifié n'existe pas
   if(is_value(bloc, value)) {
      return false;
   }
 
   m_icursor = cursor;
 
   // On se place à la fin du bloc
   while(*m_icursor != '[' && m_icursor != m_l_content.end()) {
      m_icursor++;
   }
 
   // On écrit la nouvelle valeur
   m_l_content.insert(m_icursor, '\n');
   while(s_value[i] != '\0') {
      m_l_content.insert(m_icursor, s_value[i]);
      i++;
   }
   m_l_content.insert(m_icursor, '=');
   i = 0;
   while(s_vvalue[i] != '\0') {
      m_l_content.insert(m_icursor, s_vvalue[i]);
      i++;
   }
   m_l_content.insert(m_icursor, ';');
 
   view();
 
   if(write()) {
      return true;
   }
 
   return false;
}

09/08/2010, 16h27
koala01

Je confirme ce que white-tentacle a écrit:

Non seulement, les temps d'accès aux fichiers sont très largement supérieurs aux temps d'accès mémoire, mais, de plus, tu dois te dire que les données qui se trouvent dans un fichier nécessitent un traitement avant d'être utilisées:

Dans le d'un fichier de configuration de type "ini", tu auras, par exemple, une paire "clé / valeur" que tu lira le plus souvent sous la forme d'une chaine de caractères, dans laquelle tu devra séparer le nom de la clé et la valeur, en veillant à... utiliser le bon type pour la valeur, et qu'il faudra commencer par... rechercher dans le fichier.

Tout cela peut prendre énormément de temps, dans le sens où tu effectuera, le plus souvent, une... lecture séquentielle de ton fichier et qu'avec un peu de (mal)chance, la paire clé valeur que tu recherche se trouvera toujours... tout à la fin de celui-ci (ce n'est pas moi qui le dit, c'est Murphy :D).

Si, par contre, quitte à lire les données, tu les lis "une bonne fois pour toutes" et "garde les dans un coin de la mémoire" pour les manipuler "à ton aise" en cas de besoin, tu gagne, finalement, sur les deux tableaux:

Une fois qu'elles sont "converties" pour être exploitables, tes données sont, non seulement plus facilement accessibles, mais, surtout, tu ne dois pas commencer par refaire cette conversion avant de pouvoir prendre les "mesures ad-hoc" que ta configuration impose ;)
09/08/2010, 16h32
yetimothee

J'ai mis à jour mon code (post au dessus), ça marche impec'.
Pour traiter les valeurs, j'ai créé deux templates de conversions de string -> autre type et autre type -> string.

Merci pour votre aide, je viens rarement demander conseil dans les forums, peut-être que je devrais, y a plein de bons conseils ^^

A vrai dire, j'aurais presque vu quelque chose d'encore différent...

Je me serais, par exemple, amusé à créer une structure template proche de

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
template <class K, class V>
struct KeyValue
{
    typedef K key_type;
    typedef V value_type;
    key_type key;
    value_type value;
    KeyValue(K const &k, V const & v):key(k),value(v){}
    friend ostream & operator<<(ostream& is,KeyValue const & v)
    {
        is<<key<<"="<<value;
        return is;
    }
    friend ostream & operator>>(ostream& os,KeyValue const & v)
    {
        getline(os,key,'=');
        os>>value;
    }
    struct equalFunctor
    {
        equalFunctor(K const & k):k(k){}
        K k;
        bool operator()(KeyValue const & kv) const
        {
            return (kn.key==k);
        }
    };
    struct KeyLess
    {
        bool operator()(KeyValue cost & k1, KeyValue const & k2) const
        {
            return k1.key<k2.key;
        }
    };
};
class ConfigFile
{
     typedef std::vector<KeyValue<std::string,std::string> > StringVector;
     typedef std::vector<keyValue<std::string, int> > IntVector;
    public:
        typedef StringVector::const_iterator const_string_iterator;
        typedef IntVector::const_iterator const_int_iterator;
        friend class ConfigReader;
        ConfigFile(std::string const & fname):finame(finame){}
        const_string_iterator beginStringValues() const{return strings.begin();}
        const_string_iterator endStringValues() const{reutrn strings.end();}
        const_int_iterator beginIntValues() const{return ints.begin();}
        const_int_iterator endIntVaues() const{return ints.end();}
        const_string_iterator findInStrings(std::string const &) const
        {
            return std::find(strings.begin(); strings.end(); 
                   KeyValue<std::string,std::string>::equalFunctor(s));
        }
        const_int_iterator findInStrings(std::string const &) const
        {
            return std::find(ints.begin(); ints.end(); 
                   KeyValue<std::string,std::int>::equalFunctor(s));
        }
        std::string const & filename() const{return fname;}
    private:
        std::string fname;
        StringVector strings;
        intVector ints;
 
};
class ConfigReader
{
    enum part
    {
        firstPart,
        secondPart
    };
    public:
        static void readFile(ConfigFile & cf)
        {
            part.
            std::ifstream ifs(cf.filename().c_str());
            std::string temp;
            while (std::getline(ifs, temp))
            {
                if(temp=="[ValueAsString]")
                    p=firstPart;
                else if(temp=="[ValueAsInt]")
                    p=secondPart;
                else
                {
                    std::stringstream ss(temp);
                    if(p==firstPart)
                    {
                        KeyValue<std::string, string> k;
                       ss>>k;
                      cf.strings.push_back(k);
                    }
                    else
                    {
                        KeyValue<std::string, int> k;
                       ss>>k;
                      cf.ints.push_back(k);
                    }
                }
 
           }
           std::sort(cf.strings.begin(),cf.strings.end(),
                     KeyValue<std::string,std::string>KeyLess());
           std::sort(cf.ints.begin(),cf.ints.end(),
                     KeyValue<std::string,std::string>KeyLess());
        }
};
class ConfigWriter
{
    public:
        static void writeToFile(ConfigFile.cons & cf)
        {
            std::ofsream ofs(cf.filename().c_str());
            ofs<<"[ValueAsString]"<<std::endl;
            for(const_string_iterator it= cf.beginStringValues();
                it!=cf.endStringValues();++it)
                ofs<<(*it)<<std::endl;
            ofs<<"[ValueAsInt]"<<std::endl;
            for(const_int_iterator it= cf.beginIntValues();
                it!=cf.endIntValues();++it)
                ofs<<(*it)<<std::endl;
        }
};

C'est du vite fait et non testé...

Mais, si je ne suis pas trop fatigué, et que je ne me suis pas gouru, tu devrais pouvoir utiliser tout cela sous une forme proche de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int main()
{
    ConfigFile cf("config.ini");
    ConfigReader(cf);
    /* si tu veux chercher une clé dont la valeur est une chaine */
    const_string_iterator it=cf.findStingValue("Machaine");
    if(it!=cf.endStringValue())
    {
        /* récupérer la chaine de valeur */
        std::string value=(*it).value;
        /*...*/
    }
    /* si tu veux chercher une clé dont la valeur est un int*/
    const_string_iterator it=cf.findIntValue("autrechaine");
    if(it!=cf.endStringValue())
    {
        /* récupérer l'entier de valeur */
        int value=(*it).value;
        /*...*/
    }
    /* sauvegarder la configuration */
    ConfigWriter::writeToFile(cf);
}

Evidemment:

tu peux t'amuser avec autant de spécialisation de ValueKey que tu veux (ValueKey<string, float> et autres)
Il manque la classe qui se chargera de modifier la configuration à l'exécution... Il serait sans doute pas mal de la déclarer amie de la classe ConfigFile, pour éviter d'exposer les méthodes qui permettent de modifier les différentes pairs clé / valeurs ;)
C'est du vite fait, le desing est donc perfectible :D

09/08/2010, 23h17
yetimothee
Je crains que tu te fatigues encore plus pour pas grand chose, ce que tu me marque là arrive en dehors de mes compétences immédiates.

Par exemple, ça :
Code:

1 2 friend ostream & operator<<(ostream& is,KeyValue const & v)
Ca veut dire quoi ? C'est pour assigner un opérateur '<<' qui ferait quelque chose de similaire à cout, par exemple ?

Franchement, j'ai hâte d'avoir des vrais cours de progra autre que sur le net, ça me changera au niveau rigueur, et je saurais ce qu'on attend de moi... Là ce que tu m'écris c'est sympa, mais ça me dis pas grand chose.

Ceci dit, j'vais tout de même essayer de comprendre ^^
10/08/2010, 02h59
koala01

Ce n'est pas une "assignation", c'est une définition de fonction, et, pour être précis, une surcharge de la fonction qui sert d'opérateur pour les flux ;)

En fait, les manipulateurs flux de la STL utilisent les opérateur << (sortie) et >> (entrée) pour injecter / récupérer les données.

Comme tous les flux entrant ont une base commune (istream) et que tous les flux sortants ont, eux aussi, une base commune (ostream), il est possible de redéfinir l'opérateur adéquat pour "n'importe quel flux" entrant ou sortant, qu'il s'agisse de l'entrée / sortie standard (respectivement le clavier ou l'écran(le plus souvent) ), de fichiers, ou de flux de conversion de données depuis / vers des chaines de caractères (stringstream).

Seulement, il n'est pas toujours opportun de prévoir des accesseurs ou (pire encore) des mutateurs sur l'ensemble des membres d'une structures, parce que sinon, cela revient à permettre de les modifier depuis "n'importe où".

Et comme, lorsque tu crées une fonction membre, il y a un pointeur sur l'objet passé de manière implicite (le fameux this), il faut "sortir" l'opérateur de la classe pour laquelle on le redéfini.

En effet, ces opérateurs prennent deux arguments dans un ordre bien particulier: le flux (d'entrée ou de sortie) en premier, la structure à envoyer / récupérer en second, parce que l'on écrit cin >> MonTruc; et cou << MachinChose (il faut respecter l'ordre des opérandes :D)

C'est la raison pour laquelle on déclare une amitié entre... la surcharge de l'opérateur pour la structure concernée et... cette structure elle-même ;)
10/08/2010, 04h03
yetimothee

J'étudierais tout ça plus tard, mais là tu me fais peur :lol: