Discussion :

[Veovis]

Salut,

Est ce qu'il est possible d'appeller une fonction via le nom de cette fonction (string). Je m'explique :

Code :

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

1
2
3
4
5
6
7
8
9
 
int toto() {
 
}
 
int main() {
    string t = "toto()";
    //pouvoir appeller la fonction via ce string
}

Merci pour les réponses....

[Luc Hermitte]

Non.
C'est à toi d'associer tes chaines à des fonctions (boost::bind et boost::function peuvent être une piste de réponse). Si en plus tu dois passer des arguments, cela devient encore plus compliqué.

[Veovis]

Oki merci je vais aller voir du côté de ses fonctions (bind et fonction).

[loufoque]

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
#include <iostream>
#include <map>
 
void toto()
{
     std::cout << "Je suis la fonction toto" << std::endl;
}
 
int main()
{
    std::map<std::string, void(*)()> map;
    map["toto"] = &toto;
 
    map["toto"]();
}

[Vitis_Alba]

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
#include <iostream>
#include <map>
 
void toto()
{
     std::cout << "Je suis la fonction toto" << std::endl;
}
 
int main()
{
    std::map<std::string, void(*)()> map;
    map["toto"] = &toto;
 
    map["toto"]();
}

Salut,

Je souhaiterais utiliser cette méthode, mais pas avec des fonction, plutôt avec des constructeurs. Par contre, je ne vois pas comment m'y prendre. Cela est il possible?

[Médinoc]

Pour des constructeurs, renseigne-toi sur le pattern "factory".

[Vitis_Alba]

Pour des constructeurs, renseigne-toi sur le pattern "factory".

Je récupère une chaine de caractères depuis un parser, et suivant la chaine en question, je veux créer l'objet qui lui correspond.
Je ne comprends pas commment le pattern factory peut m'aider dans ce cas. Tu pourrais m'éclairer ?

[loufoque]

Je souhaiterais utiliser cette méthode, mais pas avec des fonction, plutôt avec des constructeurs. Par contre, je ne vois pas comment m'y prendre. Cela est il possible?

Si tu veux uniquement stocker les constructeurs par défaut, peut-être.
Je sais pas si on peut avoir un pointeur vers un constructeur par contre.

[Médinoc]

Le pattern factory, ça peut être un ensemble de pointeurs vers des fonctions qui font juste un new...

Un petit pseudocode:

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
class CClasseDeBaseObjetDynamique;
class CUneClasse : public CClasseDeBaseObjetDynamique;
class CUneAutreClasse : public CClasseDeBaseObjetDynamique;
 
CClasseDeBaseObjetDynamique * CreerObjetDUneClasse(void)
{
   return new CUneClasse;
}
 
CClasseDeBaseObjetDynamique * CreerObjetDUneAutreClasse(void)
{
   return new CUneAutreClasse;
}
 
typedef CClasseDeBaseObjetDynamique (*FonctionCreatrice)(void)
map< string, FonctionCreatrice > g_fonctions;
 
void Initialiser(void)
{
   g_fonctions["UneClasse"] = CreerObjetDUneClasse;
   g_fonctions["UneAutreClasse"] = CreerObjetDUneAutreClasse;
}
 
CClasseDeBaseObjetDynamique * CreeObjet(string nomClasse)
{
   FonctionCreatrice fonc = g_fonctions[nomClasse];
   if( fonc==NULL )
      return NULL;
   CClasseDeBaseObjetDynamique * obj = fonc();
   return obj;
}

[loufoque]

On peut faire plus générique, plus simple, et sans utiliser new (qui impose allocation dynamique).

[Médinoc]

OK, je laisse faire le maître.
Montre ta méthode.

[loufoque]

On peut essayer de faire un truc similaire à boost::function.

J'ai aussi écrit ça vite fait sans tester, y'a peut-être des erreurs.
Et puis l'interface peut aussi être améliorée.

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
namespace detail
{
     template<typename T>
     void ctor_apply(void* p)
     {
          new(p) T;
     }
}
 
// un simple indicateur
template<typename T>
struct constructor_type
{
};
 
class constructor
{
    template<typename T>
    constructor(constructor_type<T>)
    {
        ctor_ = &detail::ctor_apply<T>;
    }
 
    template<typename T>
    constructor& operator=(constructor_type<T>)
    {
        ctor_ = &detail::ctor_apply<T>;
    }
 
    constructor& operator=(const constructor &c)
    {
         ctor_ = c.ctor_;
    }
 
    void apply(void *p)
    {
        ctor_(p);
    }
 
private:
    void (*ctor_)(void*);
};

un constructor peut alors contenir le constructeur par défaut de n'importe quel type.

Avec une technique similaire et si on disposait des fonctions virtuelles templates, on pourrait même appeler un constructeur prenant n'importe quel nombre de paramètres.

[Vitis_Alba]

Je vous remercie pour vos réponses, j'ai pour l'instant codé la méthode qui utilise la factory.

Loufoque ( ou quelqu'un d'autre, après tout ), pourrais tu me donner un petit exemple d'tulisation de ton code, car j'ai un peu de mal à suivre mais je voudrais bien comprendre.

[David Fleury]

[code]namespace detail
{
template<typename T>
void ctor_apply(void* p)
{
new(p) T;
}
}

Cool la méthode.

Mais j'ai quand même deux questions (points pas clair pour moi encore)
:
1. Le placement new ne poserait pas problème dans le cas d'un héritage avec des enfants de taille supérieure ?

2. Je ne vois pas trop comment utiliser ta méthode avec des classes virtuelles (on aurait plus tendance à vouloir récupérer un pointeur sur l'objet créé).

[loufoque]

L'idée de constructor est d'avoir une variable qui peut "contenir" le constructeur par défaut de n'importe quel type.
Tu l'informes du type à contenir en utilisant constructor_type.

Tu construis alors ton objet en fournissant à la fonction apply une adresse vers un emplacement mémoire suffisamment grand et avec un alignement compatible avec les objets de type que tu veux créer.
Malheureusement c'est vrai qu'en fait il aurait été pas mal que ce soit constructor qui se charge d'allouer l'objet, parce que sinon on ne connait pas le type, et donc pas la taille, de l'objet à allouer.

Peut-être qu'utiliser une interface d'allocateurs permettrait une meilleure souplesse, pour pouvoir exploiter le cas où l'on connait la taille.

Mais comment alors libérer l'objet créé ? En rajoutant un second pointeur de fonction vers une fonction qui appelle delete par exemple. (On plutôt, pour optimiser la taille, en ayant un pointeur vers une classe polymorphe qui contiendrait ces deux fonctions)

Mais si on suit le RAII, alors l'objet doit être responsable de la destruction des objets qu'il créé. Ce qui signifie alors que l'objet doit être contenu. Donc du coup, ça revient à coder boost.any.

Ou alors on se restreint au polymorphisme et à new/delete et on retourne des shared_ptr.
Ce qui correspond mieux à l'idée du Design Pattern Factory.

[David Fleury]

La solution par allocator me semble trop théorique.

Mais si on suit le RAII, alors l'objet doit être responsable de la destruction des objets qu'il créé. Ce qui signifie alors que l'objet doit être contenu. Donc du coup, ça revient à coder boost.any.

Ou alors on se restreint au polymorphisme et à new/delete et on retourne des shared_ptr.
Ce qui correspond mieux à l'idée du Design Pattern Factory.

Un simple auto_ptr suffirait pour expliciter le passage de responsibilité sur la désallocation.

[loufoque]

Faire un delete sur un type différent de celui utilisé lors du new correspondant est un comportement indéfini.
À part si le type est une base de celui utilisé lors du new et si le destructeur est virtuel.

D'où la simplicité gagnée en se restreignant au polymorphisme et à new/delete.
(Cette fonctionnalité n'est pas possible avec les allocateurs, il faut absolument que le type utilisé pour la désallocation soit le même que pour l'allocation)

[David Fleury]

Je me demande si je n'ai pas déjà vu une implémentation de ta proposition par allocator dans le livre d'Alexandrescu Modern C++ Design, où il met en place une farbrique de ce style. (peut être est-elle dispo dans loki)