Discussion :

[darkrojo]

Bonsoir,
Je suis en train de créer une classe mère qui s'occupe de gèrer mes modèles :

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
#ifndef __ABSTRACTMODEL_H__
#define __ABSTRACTMODEL_H__
 
#include <string>
#include <vector>
 
#include <boost/property_tree/ptree.hpp>
 
class AbstractModel
{
public:
    AbstractModel();
    virtual ~AbstractModel();
 
    void LoadFromFile(const std::string& path);
    void LoadFromName(const std::string& name);
 
    static std::vector<std::string> GetAvaibleModels();
 
protected:
    virtual void parse(boost::property_tree::ptree data) = 0;
 
    // functions related to files location
    static std::string basedir();
    static std::string filename();
};
 
#endif // __ABSTRACTMODEL_H__

Voici son implémentation :

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
#include "AbstractModel.h"
 
#include <boost/filesystem.hpp>
#include <boost/property_tree/info_parser.hpp>
 
AbstractModel::AbstractModel()
{
 
}
 
AbstractModel::~AbstractModel()
{
 
}
 
void AbstractModel::LoadFromFile(const std::string& path)
{
    boost::property_tree::ptree data;
    read_info(path, data); 
 
    parse(data);
}
 
void AbstractModel::LoadFromName(const std::string& name)
{
    namespace fs = boost::filesystem;
 
    fs::path location = fs::path(basedir()) / name / filename();
    LoadFromFile(location.string());
}
 
std::vector<std::string> AbstractModel::GetAvaibleModels()
{
    namespace fs = boost::filesystem;
 
    std::vector<std::string> results;
 
    for(fs::directory_iterator it(basedir()); it != fs::directory_iterator(); ++it)
    {
        if(fs::is_directory(*it))
            results.push_back(it->path().string());
    }
}
 
std::string AbstractModel::basedir()
{
    return "models";
}
 
std::string AbstractModel::filename()
{
    return "model.info";
}

Comme vous le devinez, j'ai besoin que basedir() et éventuellement filename() soient redéfinis par chaque classe fille qui représentera un modèle (PersonnageModel, ArmeModel, etc...) pour ne pas que les modèles soient mélangés.

Cepedant, lorsque je redéfini basedir() dans la classe fille BlockModel, l'appel à LoadFromName("test") va me chercher le fichier du modèle par défaut, à savoir models/test/model.info et non pas blocks/test/model.info.

Je ne vois pas comment faire pour que chaque classe fille aie son propre dossier et que cela soit directement gèré par la classe mère.

Auriez-vous des (belles) solutions à me proposer ? À la base je voulais définir ces constantes spécifiques comme ça pour faire plus propre :

Code :

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

1
2
3
4
namespace
{
    const std::string MODEL_BASEDIR = "blocks";
}

Il faudrait que cette variable soit également accessible pour les méthodes statiques telles que GetAvaibleModels().

Merci d'avance, darkrojo.

[JolyLoic]

Qu'est-ce qui t'empêche de faire :

Code :

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

1
2
3
4
5
6
7
8
9
class AbstractModel
{
public:
    static std::string baseDir;
protected:
    virtual std::string getBasedir() {return AbstractModel::baseDir;}
};
 
std::string AbstractModel::baseDir = "Base";

[darkrojo]

Je ne peux pas redéfinir la variable static AbstractModel::baseDir via ce code :

Code :

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

std::string BlockModel::baseDir = "blocks";

erreur: redefinition of 'std::string AbstarctModel::baseDir'
erreur: 'std::string AbstractModel::baseDir' previously declared here

Quand à la méthode virtuelle, j'y avais pensé mais il faut que baseDir soit accessible dans les méthodes statiques telles que AbstractModel::GetAvaibleModels(), or les méthodes virtuelles sont disponibles uniquement pour les méthodes non-statiques.

Des idées ?

[JolyLoic]

Je ne peux pas redéfinir la variable static AbstractModel::baseDir via ce code :

Code :

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

std::string BlockModel::baseDir = "blocks";

J'ai oublié de préciser que cette ligne devait être dans un .cpp, pas dans un .h

Quand à la méthode virtuelle, j'y avais pensé mais il faut que baseDir soit accessible dans les méthodes statiques telles que AbstractModel::GetAvaibleModels(), or les méthodes virtuelles sont disponibles uniquement pour les méthodes non-statiques.

L'idée est que dans les fonctions statiques, tu connais le vrai type que tu veux manipuler, donc tu utilises baseDir. Par contre, dans les contextes où tu ne connais pas ce vrai type (par exemple pour sauver une instance d'une classe dérivée), tu utilises la fonction virtuelle.

[darkrojo]

Voilà ce que j'ai quand je déplace la redéfinition de la variable statique dans leurs .cpp respectifs :

erreur: ISO C++ does not permit 'AbstractModel::baseDir' to be defined as 'BlockModel::baseDir' [-fpermisive]

Je tiens à préciser que je n'ai pas remis le 'static std::string baseDir;' dans le header de BlockModel comme je l'ai fait dans celui de AbstractModel.

[JolyLoic]

Je ne suis pas certain de ce que tu as fait.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
// A.h
class A {
static string name;
};
// A.cpp
string A::name="A";
 
// B.h
class B : public A{
static string name;
};
// B.cpp
string B::name="B";

Devrait à mon sens marcher, même si je n'ai pas vérifié dans le standard. L'idée est que dans B, name va cacher le nom name défini dans A et définir une nouvelle variable, mais ce n'est pas gênant, puisque c'est ce que tu veux.

Quoi qu'il en soit, dans le pire des cas, défini des variables avec des noms différents dans chaque classe, encore une fois, comme dans l'appel depuis une fonction statique, tu sais exactement à quelle classe tu fais référence, tu sais aussi exactement quel nom utiliser (sauf si tu veux utiliser ton code dans des templates, c'est pourquoi la solution avec le même nom me semblait préférable).

[darkrojo]

Je tiens à préciser que je n'ai pas remis le 'static std::string baseDir;' dans le header de BlockModel comme je l'ai fait dans celui de AbstractModel.

En le rajoutant comme le montrait ton code, ça fonctionne !
Merci beaucoup et bonne soirée (:

EDIT : Je ne comprends plus rien... J'ai une exeption de boost::filesystem qui me dit que le dossier "models" n'existe pas, normal puisque la méthode devrai aller chercher le dossier "blocks".

Je joins mes sources qui ont changé depuis le dernier post où je les ai présentées pour que l'on soit sur la même longueur d'onde

[JolyLoic]

J'ai l'impression que tu n'as pas compris les deux aspect du ma première réponse (ma réponse avec A et B ne détaillait que l'implémentation d'un de ces aspects).

L'idée est que dans les fonctions statiques, tu connais le vrai type que tu veux manipuler, donc tu utilises baseDir. Par contre, dans les contextes où tu ne connais pas ce vrai type (par exemple pour sauver une instance d'une classe dérivée), tu utilises la fonction virtuelle.

Là, tu n'as pas du tout fait la fonction virtuelle. Donc ton GetAvaibleModels marche bien (fonction statique) mais pas ton LoadFromName (qui devrait utiliser une fonction virtuelle).

Si je détaille mon exemple raccourci :

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
 
// A.h
class A {
static string name;
virtual string getName() {return A::name;}
};
// A.cpp
string A::name="A";
 
// B.h
class B : public A{
static string name;
virtual string getName() {return B::name;}
};
// B.cpp
string B::name="B";

[darkrojo]

Désolé, je ne devais pas être très en forme et je n'avais pas compris ; j'avoue que l'exemple me parle un peu plus

Cependant, après avoir implémenté cette fonction virtuelle, cela marche bien pour les méthodes membres de B mais pas pour la méthode statique qui se sert de A::baseDir au lieu de B:baseDir !

[darkrojo]

Je me permet de "upper" le topic en vous joignant mes sources (juste deux classes et un main) pour vous permettre de m'aider ; en effet je n'ai toujours pas trouvé d'où cela venait et je suis coincé sur mon projet : je ne peux pas prendre le risque d'avancer si la méthode que JolyLoic s'avère ne pas marcher.

Merci d'avance