Appel fonction via un string

Version imprimable

22/01/2007, 00h00
Veovis

Appel fonction via un string
Salut,

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

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....
22/01/2007, 00h31
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é.
22/01/2007, 09h04
Veovis

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

Code:

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"]();
}

Citation:
Envoyé par loufoque
Code:

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?

02/02/2007, 16h22
Médinoc

Pour des constructeurs, renseigne-toi sur le pattern "factory".
02/02/2007, 16h36
Vitis_Alba

Citation:

Envoyé par Médinoc

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 ?
02/02/2007, 19h43
loufoque

Citation:

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.

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

Un petit pseudocode:

Code:

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;
}

02/02/2007, 20h47
loufoque

On peut faire plus générique, plus simple, et sans utiliser new (qui impose allocation dynamique).
02/02/2007, 21h33
Médinoc

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

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:

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.

05/02/2007, 09h35
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.
05/02/2007, 15h13
David Fleury

Citation:

Envoyé par loufoque

[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éé).
05/02/2007, 16h49
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.
05/02/2007, 19h03
David Fleury

La solution par allocator me semble trop théorique.

Citation:

Envoyé par loufoque

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.
06/02/2007, 01h17
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)
06/02/2007, 09h45
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)