Discussion :

[Alp]

Salut à tous,

Alors c'est dans le contexte d'un langage de script.

Je souhaiterais pouvoir associer(surement dans une map) à chaque chaine la fonction qui lui correspond :
"f(a,b)" => f(a,b)

Seulement, en templatant etc, je me retrouve quand même face à un problème : comment pouvoir avec _un type_ pouvoir représenter toutes les fonctions ?
Soit FuncType ce type, je ferais alors un :
std::map < std::string , FuncType > ma_map;

Ensuite je la remplirai ce n'est pas un problème. Mais comment designer le tout pour obtenir un FuncType ?

Merci

[loufoque]

Il faut distinguer selon les paramètres de la fonction

[Alp]

Et pour le type de retour?

En gros, tu concevrais ça comment?

A la limite, faire une map pour les fonctions sans arguments, une pour celles à 1 argument, une pour celles à 2 arguments, etc, ça peut être faisable.

Dans ce cas là tu ferais comment ?

[Laurent Gomila]

boost::function pour stocker les fonctions (function<void ()>, function<void (int)>, function<void (int, int)>, ... par exemple) avec boost::bind pour les créer comme il faut.

[Alp]

Hmm, j'y ai pensé.
Mais ça marchera pas si je mets des boost::function0<...> boost::function1<...> etc ..., non ?
Puisqu'il faudrait un seul type, pour définir ma map.

EDIT : j'ai rien dit, j'avais oublié qu'en fait on a la possibilité d'utiliser les deux : boost::function< > et boost::functionN< > . Désolé.

[Alp]

Ah loufoque, en effet j'étais pas allé aussi loin dans mon raisonnement.
Je pense que ça devrait faire l'affaire.
Par contre :

Code :

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

1
2
3
4
5
 
template<typename R> R operator()()
{
        return f_();
}

Ca marche ça? Il me semblait que non. Que le compilo ne déduisait pas R tout seul.

[loufoque]

Hmm en fait tu peux peut-être faire un wrapper universel...
Un truc du style

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
struct ifunction_base
{
    template<typename R> virtual operator()();
    template<typename R, typename V1> virtual operator()(const V1&);
    template<typename R, typename V1, typename V2> virtual operator()(const V1&, const V2&);
};
 
template<typename R> class ifunction : public ifunction_base
{
    boost::function<R> f_;
 
public:
    ifunction(const boost::function<R>& f) : f_(f)
    {
    }
 
    R operator()()
    {
         return f_();
    }
};
 
class Function
{
   ifunction_base* f_;
 
public:
   template<typename R> Function(const boost::function<R>& f) : f_(new ifunction<R>(f));
   {
   }
 
   template<typename R> R operator()()
   {
        return f_();
   }
 
   ~Function()
   {
        delete f_;
   }
};