Discussion :

[Kevin_Mylano]

Bonjour à tous et à toutes.

Je sollicite aujourd'hui votre aide car je rencontre une "petite" difficulté sur un projet :

Le constructeur de la classe chargée de lire un fichier XML de configuration est appelée avant le lancement de l'application.

Or, mon but est de créer de nouveaux fichiers de configuration XML. Or pour la lecture, je dois passer obligatoirement par le constructeur de la classe chargée de lire les XML.

Cependant, en essayant de la surchargée avec un "const char *" pour le non du fichier XML produit à lire, ou de rajouter ce paramètre à son constructeur : il ne le lit jamais.

En gros, je dois produire des fichiers XML que je dois lire qui devraient exister dès le début si on voudrait que cela fonctionne correctement.

Si ce n'est pas de la magie je ne vois pas ce que c'est.

Bien à vous,

KM.

[dalfab]

Bonjour,

Je ne comprends pas bien ton problème. Peux-tu nous montrer ce que tu fais.
Si un constructeur a un paramètre const char*, il est appelé dès l'instant où tu crées une instance en lui passant ce paramètre.

[koala01]

Salut,

Si j'ai bien compris, tu as une classe qui pourrait être nommée XmlReader, dont le but est de ... lire les informations contenues dans un fichier XML et de créer des données à partir de là. Est-ce bien de cela que l'on parle

Mais, si c'est cela, pourquoi voudrais tu qu'une instance de cette classe soit créée avant même que le programme ne commence à s'exécuter

Qu'est ce qui t'empêche, par exemple, de créer un "mono state machine", par exemple, en créant une fonction qui pourrait être aussi simple que

Code :

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

1
2
3
4
XmlReader & getReader(){
    static XmlReader reader{"fichier.xml"};
    return reader;
}

qui permettrait de créer l'instance de ta classe la première fois que tu en as besoin et de la récupérer à chaque fois que tu en as besoin par la suite, sans avoir à la recréer à chaque fois

Et plus important encore: pourquoi voudrais tu lui transmettre le nom du fichier à utiliser au moment de sa création

Car, entendons nous: il n'est jamais bon de garder un fichier ouvert plus que le temps "strictement nécessaire", ne serait-ce que à cause des verrous que les systèmes d'exploitation posent sur les fichiers quand ils sont utilisés.

Le temps "strictement nécessaire" correspond donc ici au temps qu'il faudra pour parcourir le fichier et charger les informations qu'il contient en mémoire, de manière à ce qu'il ne soit même plus nécessaire de ré-ouvrir le fichier par la suite lorsque nous voudrons accéder à ces données.

Or, si on n'a besoin du nom de fichier que pour pouvoir l'ouvrir afin de lire les données qu'il contient, à quoi est ce que cela peut servir de maintenir ce nom de fichier au niveau de la classe

Et, surtout, est ce que cela ne pose pas une restriction majeure à l'utilisation même de ta classe dans le sens où, une fois ce nom défini, il semble tout à fait hors de question de décider de changer le nom du fichier qui sera utilisé

Dés lors, pourquoi ne prévoirait-on pas plutôt de fournir ce nom ... uniquement lorsque l'on souhaite charger les informations contenues dans le fichier, ce qui nous donnerait 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
class XmlReader{
public:
    void loadFromFile(std::string const & filename){
        /* plusieurs possibilités s'offrent à nous:
         * soit un fichier portant un nom différent a déjà été chargé, et il faudra donc "oublier" les informations
         * qu'il contennait
         */
        if(loaded_ && filename_!= filename)
            unload();
        /* soit, aucun fichier n'est chargé (ou l'on vient d'en faire "oublier" le contenu, ce qui revient au même
         * et il faut donc charger le fichier dont le nom est fourni
         */
        if(! loaded_){
            /* on ouvre alors le fichier */
            std::ifstream ifs{filename};
            /* si ca ne se passe pas bien, on sort sur une erreur */
            if(! ifs)
                throw std::runtime_error("unable to open requested file");
            /* sinon, on lance la procédure de lecture, en transmettant le fichier qui est ouvert comme paramètre */
            readDatas(ifs);
            /* n'oublions pas mettre le nom du fichier à  jour, ainsi que le status loaded_ */
            loaded_=true;
            filename_=filename;
       }
       // arrivé ici, nous sommes sur que  c'est le fichier dont le nom a été fourni qui a été chargé, et c'est 
       // exactement ce que l'on voulait
    }
    /* pour savoir si cela vaut la peine de relire le fichier ou non */
    bool shouldReload(std::string const & filename) const{
        if(! loaded_)
            return true;
        return filename_!= filename;
    }
private:
    /* les fonctions qui nous permettent de travailler */
    void unload(){
        /* tout ce qu'il faut  pour faire "oublier" contenu du fichier 
         * à faire selon les informations que tu garde en mémoire
         */
        filename_.clear();
        loaded_=false;
      }
      void readDatas(std::istream & ifs){
          /* tout ce qu'il faut  pour lire le fichier
           * qui peut éventuellement faire appel à des fonctions plus simples
           * qui nécessiteront également l'accès au fichier (le donner comme paramètre sous la forme d'une référence
           * 
           * toutes ces fonctions d'extractions devraient lancer une exception si, par malheur, 
           * elles se trouvaient dans l'incapacité de faire leur travail correctement
           */
    }
    /* et les données qui permettent de faire les tests */
    std::string filename_;
    bool loaded_{false};
};

Et nous pourrions donc "corriger" notre fonction d'obtention d'instance pour lui donner une forme proche de

Code :

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

1
2
3
4
5
6
XmlReader & getReader(std::string const & filename="nom_par_defaut.xml"){
    static XmlReader reader;
    if(reader.shouldReload(filename))
        reader.loadFromFile(filename);
    return reader;
}

L'utilisation d'un nom de fichier par défaut permettant à l'utilisateur de cette fonction de n'avoir pas ** forcément ** à s'inquiéter du nom du fichier qui sera lu

[Bousk]

Le constructeur de la classe [...] est appelée avant le lancement de l'application.

Kamoulox ?