Discussion :

[raoulchatigre]

Bonjour,

J'aimerais savoir s'il est possible en C++ d'instancier une classe à partir d'un nom provenant d'une variable.
Habitué à PHP, je sais que c'est possible, l'idée serait de faire :

Code :

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

1
2
string className = "maClasseFille";
MaClasseMere uneInstance = maClasseFille.c_str()::getInstance();

Pour ce que je connais de la souplesse du C++ je doute qu'une telle chose soit possible. Je me trompe ?
Sinon : quelle solution donc permet de palier au problème ?

[Médinoc]

Tu ne peux.

Mais tu peux utiliser le Design Pattern "Factory", pour créer des classes créatrices.
Et ensuite, te créer une map< string, Factory* >...

C'est ce que font les MFC avec les macros de type DECLARE_DYNCREATE, par exemple.
Sans compter COM, qui fait encore plus complexe, mais ne nécessite pas les MFC...

[raoulchatigre]

Bien,

J'aurais au passage du préciser que je développe pour Linux (donc avec g++).

Je pense reproduire le même principe en utilisant ce principe dans la classe mère :
(ce code ne compile pas forcément, mais l'idée est derrière)

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
 
public class maClasseMere
{
  public static getUneDeMesFilles(string sonPetitNom)
  {
    switch(sonPetitNom)
    {
       // ... on return la fille qui correspond au nom
    }
 
  }
 
}
 
maClasseMere uneFille = maClasseMere::getUneDeMesFilles("laCadette");

Si j'ai bien compris le principe de factory, je serai tout de même forcé de "nommer" à un moment ou a un autre mes classes, dans le switch{} en l'occurence.

[Médinoc]

À cela près que switch() ne marche que sur les nombres.
Typiquement, tu peux créer une map, par contre...

Typiquement, cette map sera un singleton, et ainsi tu pourras la remplir dans le constructeur de ta factory...

[raoulchatigre]

Dammit, vilain switch !

Typiquement, cette map sera un singleton, et ainsi tu pourras la remplir dans le constructeur de ta factory...

Heu excuses moi, j'ai du mal à te suivre : une map singleton ?

Bon, je crois que je veux aller trop vite en besogne, je vas commencer par faire fonctionner ma nouvelle structure avec des noms de classes en dur et je me pencherai sur l'option des factory ensuite.

Je recréerai un thread si besoin, merci en tout cas !

PS: Heu je clique sur délestage ou résolu ?

[koala01]

Salut,

Le singleton est, tout simplement, un modèle de conception qui s'assure qu'il n'existera jamais qu'une instance de l'objet...

Comme il est fréquent qu'il y ait plusieurs types d'objets totalement différents dont on veuille n'avoir jamais qu'une seule instance maximum pour chacun des type, le plus facile est d'avoir recours à un singleton modèle, et au CRTP:

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
 
template <class T>
class Singleton
{
    public:
        static T& getInstance()
        {
            if(!instance)
                instance=new T;
            return instance;
        }
        static void destroy()
        {
             delete instance;
             instance=NULL
        }
    protected:
        Singleton(){}
        ~Singleton() {}
    private:
        T* instance;
         /* interdiction de la copie */
         Singleton(Singleton&);
         void operator= (Singleton&);
};
template <class T>
T* Singleton::instance=NULL;

Sur base de ce singleton, nous allons créer un type qui va contenir l'ensemble des factories qui peuvent nous intéresser.

Cela prendra 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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
class FactoryHolder: public Singleton<FactoryHolder>
{
    public:
       /* mise en place du CRTP */
       friend class Singleton<FactoryHolder>;
       /* permet d'ajouter une nouvelle factory */
        void registerFactory(const std::string& fn, Facotry* fac)
        {
             items.insert(std::make_pair(fn, fac);
        }
        /* permet de récupérer une factory */
        Factory* getFactory(const std::string& name)
        {
            std::map<std::string, Factory*>::iterator it=items.find(name);
            if(it==items.end())
                return NULL;
            return (*it).second;
        }
        /* permet de supprimer une factory (si c'est dans tes intentions ;) */
        void unRegisterFactory(const std::string& name)
        {
            std::map<std::string, Factory*>::iterator it=items.find(name);
            if(it!=items.end())
            {
                delete (*it).second;
                items.erase(it);
            }
        }
    private:
        std::map<std::string, Factory*> items;
        FactoryHolder(){}
        ~FactoryHolder()
        {
            for(std::map<std::string, Factory*>::iterator it= items.begin();
                 it!=items.end();++it)
                delete (*it).second;
        }
        /* copie interdite */
        FactoryHolder(FactoryHolder&);
        void operator=(FactoréHolder&);
};

A l'utilisation, cela se passera à peu pres comme ceci:

Code :

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

1
2
3
4
5
6
/*Chaque fois que tu veux insérer une nouvelle factory dans la map */
FactoryHolder::getInstance().registerFactory("le_nom",new lanouvelfactory());
/* chaque fois que tu veux supprimer une factory */
FactoryHolder::getInstance().unRegisterFactory("le_nom_a_supprimer");
/* caque fois que tu veux utiliser une factory */
FactoryHolder::getInstance().getFactory("le_nom_recherche").laMethodeDinterface();

(il va de soi que "le_nom","le_nom_a_supprimer" et"le_nom_recherche" peuvent être des variables de type std::string ou tout type disposant d'une méthode de conversion vers celles-ci

Cela pourrait donc prendre une forme proche de

Code :

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

1
2
3
4
5
6
7
std::stringstream ss;
std::string c1;
int i2;
std::string c3;
/* récupération des trois données... ou tu le veux */
ss<<c1<<p2<<c3;
FactoryHolder::getInstance().registerFactory(ss.str(),new lanouvelfactory());

Evidemment, toutes les factories devront, pour bien faire, dériver d'une classe "Factory" qui présentera l'interface qu'on compte utiliser

PS: tu peux cliquer sur résolu, délestage, c'est plutôt pour demander le nettoyage du fil de discution