ouvrir un fichier en lecture et en écriture

Je souhaiterai savoir si, une fois un fichier ouvert en écriture, il est possible de l'ouvrir en lecture sans l'avoir fermé préalablement en écriture. En fait, je construit une classe dont certaines fonctions lisent le fichier et dont d'autres fonctions écrivent dedans.
D'une façon générale, quand un fichier est attaché à un objet, quelle est le meilleur endroit pour ouvrir le fichier et le fermer ? Est-ce dans le constructeur pour l'ouverture et dans le destructeur pour la fermeture ? Une autre solution serait d'ouvrir et de fermer le fichier dans la fonction qui va écrire ou lire le fichier, au risque d'ouvrir et de fermer le fichier à de multiples reprises à chaque fois que la fonction est appellée.

Merci pour vos conseils.

Salut,

De manière générale, il n'y a aucun sens à vouloir faire les deux en même temps:

Soit, on se trouve dans "une phase" de lecture du fichier, et on continue à le lire, soit on se trouve dans "une phase" d'écriture dans le fichier, et on continue à écrire dedans.

Si l'on souhaite passer d'une phase à l'autre, il faut, avant tout, mettre fin à la phase en cours avant d'envisager de lancer l'autre.

De plus, il est rarement opportun de monopoliser les ressources plus que nécessaire, surtout si ces ressources risquent d'être manipulée "en dehors" de l'application que tu écris, et c'est le cas des flux, de manière générale.

L'idéal consiste donc, le plus souvent, à ne maintenir dans ta classe qu'une chaine de caractère représentant le nom du fichier que tu souhaite manipuler, et à ne déclarer une variable te permettant réellement d'accéder à ce fichier (en lecture ou en écriture, selon la phase dans laquelle tu te trouve) que... dans la fonction ad-hoc.

Tu pourrais donc envisager une classe proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 class MaClass { public: MaClass(std::string const & fn):m_filename(fn) { } Type readFromFile( /* argument potentiels */) { std::ifstream ifs(m_filename.c_str()); /* lecture depuis ifs */ } bool writeToFile(/* argument potentiels */) { std::ofstream ofs(m_filename.c_str()); /* écriture dans ofs */ } };
voire, de prévoir une fonction prenant en paramètre un flux d'entrée ou un flux de sortie dont le but est d'effectuer la lecture (resp l'écriture) depuis /dans le flux...

Cela nous emmènerait vers une classe proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class OtherClass { public: std::ifstream & read(std::istream & ifs) { /* lecture des valeurs propre à "this" depuis ifs */ return ifs; } std::ofstream & write(std::ostream & ofs) const { /* écriture des valeurs propres à "this" dans ofs */ return ofs; } };
Ainsi, la classe MaClass pourrait en réalité ressembler à
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 class MaClass { public: MaClass(std::string const & fn):m_filename(fn) { } Type readFromFile( /* argument potentiels */) { std::ifstream ifs(m_filename.c_str()); OtherClass temp; while(temp.read(ifs)) { items.push_back(temp); } } bool writeToFile(/* argument potentiels */) { std::ofstream ofs(m_filename.c_str()); if(!ofs) return false; for(size_t i=0;i<items.size();++i) if(! items[i].write(ofs)) return false; return true; } private: std::vector<OtherClass> items; };
Il existe d'autres posiblités d'utilisation des flux, de manière générale...

un petit tour du coté de la partie dédiée de la FAQ pourra surement t'ouvrir des perspectives :D

Merci pour ces infos. Je vais essayer de mettre ça en pratique :P