Stockage de fonctions

Version imprimable

30/10/2006, 19h05
Alp

Stockage de fonctions

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
30/10/2006, 19h16
loufoque

Il faut distinguer selon les paramètres de la fonction
30/10/2006, 19h22
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 ?
30/10/2006, 20h40
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.

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

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

30/10/2006, 20h44
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é.
30/10/2006, 20h47
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:

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.

En rajoutant les R juste après virtual dans ifunction_base que tu avais oublié, et en corrigeant quelques fautes de frappes, le code donne ça :
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 struct ifunction_base { template<typename R> virtual R operator()() = 0; template<typename R, typename V1> virtual R operator()(const V1&) = 0; template<typename R, typename V1, typename V2> virtual R operator()(const V1&, const V2&) = 0; }; 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_; } };
Et j'ai ces erreurs :

Citation:

main.cpp:6: error: invalid use of `virtual' in template declaration of `virtual R ifunction_base::operator()()'
main.cpp:7: error: invalid use of `virtual' in template declaration of `virtual R ifunction_base::operator()(const V1&)'
main.cpp:8: error: invalid use of `virtual' in template declaration of `virtual R ifunction_base::operator()(const V1&, const V2&)'
main.cpp: In member function `R Function::operator()()':
main.cpp:37: error: no match for call to `(ifunction_base) ()'

avec g++, 3.x

et

Citation:

.\Source1.cpp(6) : error C2072: 'operator ()' : initialization of a function
.\Source1.cpp(6) : error C2898: 'R operator ()(void)' : member function templates cannot be virtual
.\Source1.cpp(7) : error C2072: 'operator ()' : initialization of a function
.\Source1.cpp(7) : error C2898: 'R operator ()(const V1 &)' : member function templates cannot be virtual
.\Source1.cpp(8) : error C2072: 'operator ()' : initialization of a function
.\Source1.cpp(8) : error C2898: 'R operator ()(const V1 &,const V2 &)' : member function templates cannot be virtual

avec VC2005

30/10/2006, 21h09
Jean-Marc.Bourguet

Les membres templates ne peuvent pas être virtuels.
30/10/2006, 21h10
Alp

Même si il y a encore des fautes car il ne faut pas qu'elles soient virtuelles pures, je me suis trompé, j'aimerais savoir pourquoi une fonction membre template ne peut être virtuelle, et donc comment faire?
30/10/2006, 21h21
Jean-Marc.Bourguet

Citation:

Envoyé par Alp

j'aimerais savoir pourquoi une fonction membre template ne peut être virtuelle

Personne n'a proposé la chose au commité sous une forme qui a convaincu suffisemment de monde pour faire passer la proposition.

Cette réponse n'aide vraissemblablement pas. Je crois que le fond est que les deux concepts se marient mal en C++. J'aurais du mal à proposer une sémantique évidente, surtout quand on considère les spécialisations explicites, sans commencer à parler de la manière d'implémenter cette sémantique dans le cadre des implémentations traditionnelles de la généricité (génération du code spécialisé lors de la compilation) et des fonctions virtuelles (utilisation d'une table de pointeurs vers fonction) en C++.
30/10/2006, 21h27
Alp

C'est vrai que cela se marie mal.
Mais j'ai trouvé surprenant au début qu'ils soient carrément incompatibles.
Je pensais que cela serait autorisé quand même.

Qu'en est-il pour mon problème alors? Vois tu une autre solution ?

Citation:

Envoyé par Alp

comment faire?

Ajouter un niveau d'indirection de plus. Une piste à complèter:

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
template <typename R> struct ifunction0;
template <typename R, typename P1> struct ifunction1;
 
struct ifunction_base
{
  template<typename R> R operator()();
  template<typename R, typename P1> R operator()(P1 const&);
};
 
template <typename R>
struct ifunction0: ifunction_base
{
  typedef R (*fnType)();
  ifunction0(fnType ptr) : myPtr(ptr) {}  
  R operator()() { return myPtr(); }
private:
  fnType myPtr;
};
 
template <typename R, typename P1>
struct ifunction1: ifunction_base
{
  typedef R (*fnType)(P1 const&);
  ifunction1(fnType ptr) : myPtr(ptr) {}
  R operator()(P1 const& p1) { return myPtr(p1); }
private:
  fnType myPtr;
};
 
template <typename R> R operator()()
{
  ifunction0<R>* self = dynamic_cast<ifunction<R>*>(this);
  assert(self != 0);
  return self->operator()();
}
 
template <typename R, typename P1> R operator()(V1 const& p1)
{
  ifunction1<R, V1>* self = dynamic_cast<ifunction<R, P1>*>(this);
  assert(self != 0);
  return self->operator()(p1);
}

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
43
44
45
46
47
48
49
50
51
52
53
54
#include <iostream>
 
template <typename R> struct ifunction0;
template <typename R, typename P1> struct ifunction1;
 
struct ifunction_base {
    template<typename R> R operator()();
    template<typename R, typename P1> R operator()(P1 const&);
};
 
template <typename R> struct ifunction0: ifunction_base {
    typedef R (*fnType)();
    ifunction0(fnType ptr) : myPtr(ptr) {}
 
    R operator()()
    {
        return myPtr();
    }
    private:
    fnType myPtr;
};
 
template <typename R, typename P1> struct ifunction1: ifunction_base
{
    typedef R (*fnType)(P1 const&);
    ifunction1(fnType ptr) : myPtr(ptr) {}
    R operator()(P1 const& p1)
    {
        return myPtr(p1);
    }
    private:
    fnType myPtr;
};
 
template <typename R> R ifunction_base::operator()()
{
    ifunction0<R>* self = dynamic_cast<ifunction0<R>*>(this);
    assert(self != 0); return self->operator()();
}
 
template <typename R, typename P1> R ifunction_base::operator()(P1 const& p1)
{
    ifunction1<R, P1>* self = dynamic_cast<ifunction1<R, P1>*>(this);
    assert(self != 0); return self->operator()(p1);
}
 
int f() { return 42; }
 
int main()
{
    ifunction_base* pf = new ifunction0<int>(f);
    // comment appeler f ?
    return 0;
}

Voilà ou en est le code.

Mais comment invoquer f maitenant ?

30/10/2006, 22h14
Alp

Je pensais que ça serait (*pf) ()
mais j'ai

Citation:

main.cpp:54: error: no match for call to `(ifunction_base) ()'

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include <iostream>
#include <boost/function.hpp>
 
template <typename R> struct ifunction0;
template <typename R, typename P1> struct ifunction1;
 
struct ifunction_base {
    template<typename R> R operator()();
    template<typename R, typename P1> R operator()(P1 const&);
    virtual ~ifunction_base() { }
};
 
template <typename R> struct ifunction0: ifunction_base {
    typedef R (*fnType)();
    ifunction0(fnType ptr) : myPtr(ptr) {}
 
    R operator()()
    {
        return myPtr();
    }
    private:
    fnType myPtr;
};
 
template <typename R, typename P1> struct ifunction1: ifunction_base
{
    typedef R (*fnType)(P1 const&);
    ifunction1(fnType ptr) : myPtr(ptr) {}
    R operator()(P1 const& p1)
    {
        return myPtr(p1);
    }
    private:
    fnType myPtr;
};
 
template <typename R> R ifunction_base::operator()()
{
    ifunction0<R>* self = dynamic_cast<ifunction0<R>*>(this);
    assert(self != 0); return self->operator()();
}
 
template <typename R, typename P1> R ifunction_base::operator()(P1 const& p1)
{
    ifunction1<R, P1>* self = dynamic_cast<ifunction1<R, P1>*>(this);
    assert(self != 0); return self->operator()(p1);
}
 
int f() { return 42; }
 
int main()
{
    ifunction_base* pf = new ifunction0<int>(f);
    std::cout << pf->operator()<int>();
    return 0;
}

Voilà.
Cependant je ne crois pas qu'il soit possible de s'abstraire à devoir connaitre le type de retour de la fonction ...

31/10/2006, 09h09
Jean-Marc.Bourguet

Il n'y a rien qui permette de déduire le type du résultat. Donc tu dois le spécifier:

Code:

pf->operator()<int>();

Il n'y a guère d'intérêt à utiliser la syntaxe des opérateurs.

Note que j'ai oublié qu'il faut absolument un membre virtuel dans ifunction_base pour que le dynamic_cast fonctionne. Par exemple le destructeur.

Edit: j'avais pas vu qu'il y avait une deuxième page. Tu as tout trouvé tout seul.
31/10/2006, 09h45
Alp

Oui oui. En relisant le code je me suis aperçu qu'il manquait le destructeur virtuel.
A la limite, si je me débrouille pour faire une map par type de retour, ça ira.
Pour un langage de script très simple, je retournerai surement des int, des double peut être, et des strings.

Merci en tout cas, bonne journée