Discussion :

[asari29]

bonjour, j'espère que quelqu'un pourra me répondre. Dans un programme, j'utilise des fstream. ma question est la suivante, y a t-il un moyen de récuppérer le bitmask openmode qui est initialisé en partie avec la méthode open(...).

Je souhaiterais qu'une routine prenne un fstream en parametre et détermine son mode d'ouverture.

ex:

void routine (fstream iFstream)
{
if(iFstream... ^ ios_base::in) cout<<"flux en lecture"<<endl;
else cout<<"flux en ecriture"<<endl;
}

C'est ce qu'il faut mettre dans le test qui me pose problème
(L'exemple est bete mais c'est pour illustrer ma demande)

merci d'avance

[Jeromnimo]

Bonjour,

je pense que la méthode flags (http://www.cppreference.com/cppio/flags.html) est la réponse à ton problème

[asari29]

je suis déjà allé voir du coté de cette méthode qui me parrait un peu obscure mais je crois quelle ne concerne que le bitmask fmtflag et pas le bitmask openmode .
Sauf erreur de ma part bien sur... Merci quand même pour ta réponse rapide

[koala01]

Salut,

Typiquement, je ne vois aucune raison de vouloir savoir comment a été ouvert un flux de fichier...

Du moins, j'estime (et je ne suis surement pas le seul dans le cas) que, si tu en viens à te poser la question, c'est qu'il y a visibilement un problème de conception quelque part.

En effet, la décision d'ouvrir un fichier en lecture ou en écriture intervient bien avant celle d'avoir un acces "particulier".

En outre, la surcharge des opérateurs << et >> aidant, il est normal et cohérent que l'opérateur << soit utilisé pour écrire dans un fichier et que l'opérateur >> serve à lire dedans, et que la variable servant de flux devra donc être du type correspondant

Au final, tu peux donc te trouver soit dans une situation dans laquelle tu écris deux fonctions (ou méthodes) sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
void readFromFile(const std::string& filename)
{
    std::ifstream ifs(filename.c_str());
    /* lecture du fichier */
}
void writeToFile(const std::string& filename) const
{
    std::ofstream ofs(filename.c_str());
    /* écriture dans le fichier */
}

et dans laquelle tu décidera s'il s'agit de lire ou... d'écrire, soit dans une situation dans laquelle tu surchargera les opérateurs << et >> sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class MaClass
{
    /* constructeurs, destructeurs et opérateurs d'affectations sont passés
     * car sans intérêt ici 
     */
    friend std::ostream& operator<<(std::ostream& oss, const MaClass& c)
    {
        /* écriture des informations de la classe dans le flux sortant */
        return oss; //permettra l'appel "en cascade" ;)
    }
    friend std::istream& operator>>(std::istream& iss, MaClass& c)
    {
        /* lecture des informations de la classe au départ du flux entrant */
        return iss;//permettra l'appel "en cascade" ;)
    }
}

[asari29]

Merci pour cette réponse pleine de bon sens. La raison pour laquelle je souhaitais connaitre le mode d'ouverture du flux est que je souhaite produire un module d'accès aux données générique. A force d'obstraction, le mode d'ouverture du fichier ne se propage pas dans les classe utilisatrice.
Or il m'est neccessaire a un moment donné de récupurer un flux et de faire un initR() dans le cas où il est en lecture, et un initW() si il est en ecriture.
Dans le cas d'un fichier, initR() ne fait rien par contre initW() ecrit l'entete. Cette entet ne peux pas etre ecrite au préalable puisque l'objet qui qui instancie le flux ne connait pas encore les information qui figureront dans l'entete.
Peut etre est ce un problème se conception bien que je vois difficilement une maniere différente de proceder dans cas ( je reste un débutant et n'est peut etre pas encore assez de clairevoyance quant a la conception d'un module "générique", disons plutot d'abstraction des données)

Toujours est-il que j'ai opté pour un enum appartenant à la classe contenant le flux qui me dit si le flux est fermé, en lecture, en ecriture ou les deux.
Je vous remercie pour votre aide, à une prochaine fois!

[koala01]

Je te déconseillerais de travailler avec un iofstream...

je te conseillerais de travailler avec deux classe qui instancient le flux:

la première qui ouvre le fichier "en lecture", et la seconde qui l'ouvre en "écriture".

Pour toutes les autres classes, les opérateurs << et >> ou les méthodes readFromFile et writeToFile suffisent

Au final, tu obtiens donc une classe proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
/* la classe qui écrit dans le fichier 
 * on fournit le nom de fichier au constructeur qui:
 * - va ouvrir le fichier en écriture
 * - va s'assurer que le fichier est bien ouvert (lancer une exception si ce
 *    n'est pas le cas)
 */
class Saver
{
    public:
        Saver(const std::string& filename):
             ofs(filename.str()), obj(obj)
         {
             if(!ofs)
                 throw FileNotFound();
        }
        ~Saver(){}
        /* méthode d'écriture de l'objet principal
         * @ in : référence constante vers l'objet qui contient tous les
                  autres
         */
        void Save(const ObjetPrincipal& obj)
        {
            ofs<<obj.entete()
                <<obj.membre1()
                <<obj.membre2()
                <<obj.membre3()
                <<...
        }
    private:
        std::ofstream ofs;
};
 
/* la classe qui lit dans le fichier 
 * on fournit le nom de fichier au constructeur qui:
 * - va ouvrir le fichier en lecture
 * - va s'assurer que le fichier est bien ouvert (lancer une exception si ce
 *    n'est pas le cas)
 */
class Loader
{
    public:
        Loader(const std::string& filename):
             ifs(filename.str())
        {
            if(!ofs)
                throw FileNotOpen();
        }
        ~Loader(){}
        /* méthode de lecture de l'objet principal
         * @ in : référence (non constante ;) ) vers l'objet qui contient tous
                  les autres
         */
        void load(ObjetPrincipal& obj)
        {
            ifs>>obj.entete()
                >>obj.membre1()
                >>obj.membre2()
                >>obj.membre3()
                >>...
        }
    private:
        std::ifstream ofs;
};

En effet, quand tu prend la décision d'écrire les information, tu va créer une instance de Saver, et appeler la méthode save(), et quand, inversement, tu va vouloir lire les informations, tu va créer une instance de Loader et appeler la méthode load...

Alternativement, tu peux envisager de créer l'objet qui contient tous les autres sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class ObjetPrincipal
{
    public:
        ObjetPrincipal(/* parametres éventuels */): /*liste d'initialisation */
        { /* vérifications éventuelles */
        }
        ~ObjetPrincipal(){/* ce qui va bien */}
        void writeToFile(const std::string& filename)
        {
            /* ouverture du fichier */
            std::ofstream ofs(filename.c_str());
            membre1.writeToStream(ofs);
            membre2.writeToStream(ofs);
            membre3.writeToStream(ofs);
            /*...*/
        }
        void readFromFile(const std::string &filename)
        {
            /* ouverture du fichier */
            std::ifstream ifs(filename.c_str());
            membre1 = Type1::readFromStream(ifs);
            membre2 = Type2::readFromStream(ifs);
            membre3 = Type3::readFromStream(ifs);
        }
};

En ayant, pour chaque type quelque chose ressemblant à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Type1
{
    public:
        Type1(/*parametres */):/*liste d'initialisation */
        {/* vérifications */}
        ~Type1(){/* ce qui va bien */}
        void writeToStream(std::ostream& ofs)
        {
             /*écriture des informations */
        }
        static Type1& readFromStream(std::istream& ifs)
        {
            /* - lecture des informations utiles
             * - vérification de la cohérence
             */
            return Type1(/*parametres sur base de la lecture */);
        }
}

Le tout en sachant que rien ne t'empêche malgré tout de prévoir un constructeur par défaut pour tes différents objet, et d'invoquer readFromStream pour les différents membres, selon une logique à déterminer, ni d'invoquer writeToStream pour les membres des objets "Type1" et autres

Quoi qu'il en soit, tu en arrive à une situation qui fait que, quelle que soi ta décision, la sauvegarde ou la lecture se fera "en cascade", et qui t'évite d'avoir à te poser la question de savoir ce que l'utilisateur veut faire

[JolyLoic]

D'autres possibilités :
- Il est possible de stocker l'information de ton choix directement dans un flux (xalloc, pword, iword)
- Il est peut-être possible d'utiliser dynamic_cast pour savoir si ton flux est un descendant de ostream
- Il est peut-être possible de templatiser tout ton code en fonction du type de flux, et d'utiliser la surcharge de fonction pour résoudre ce qui va bien dans les couches basses (c'est ce que fait boost::serialization)