Discussion :

[xwindoo]

Bonjour à tous,

J'ai créée un implémentation de foncteurs permettant de stocker des pointeurs de fonctions de tout type. Je vous en donne un extrait :

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
class NullType {};
class Functor {};
 
template <class R = void(), class C = NullType>
struct Function;
 
/* Fonctions libres sans paramètre */
template<class R>
class Function<R()> : public Functor
{
private:
	typedef R (*F)();
 
public:
	Function(F f) : m_f(f) {}
	R operator ()() { return m_f(); }
 
private:
	F m_f;
};
 
/* [...] */
 
/* Fonctions membres const à un paramètre */
template <class R, class T1, class C>
struct Function<R(C::*)(T1) const, C> : public Functor
{
private:
	typedef R (C::*F)(T1) const;
 
public:
	Function(F f, C c) : m_f(f), m_c(c) {}
	R operator ()(T1 t1) { return (c.*m_f)(t1); }
 
private:
	F m_f;
	C m_c;
};

Voila mon problème : j'aimerai pouvoir stocker ces foncteurs, par exemple dans une list de la stl. Cependant ce n'est pas possible puisque tous les foncteurs sont d'un type différent. Exemple d'utilisation :

Code :

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

1
2
3
4
5
 
void f() {} // une fonction libre
 
Function<void ()> F(&f); // le foncteur qui encapsule cette fonction
F(); // et l'utilisation du foncteur qui va appeler f()

Si tous les foncteurs à stocker sont de type Function<void()> pas de probleme, mais ce n'est pas le cas.

J'ai donc pensé à faire hériter les classes Function d'une classe mère commune Functor. Dans ce cas on peux effectivement stocker n'importe quel type de foncteurs (en utilisant le polymorphisme) mais il faudra alors faire un reinterpret_cast pour l'utiliser; de plus on perd les paramètres template (d'où le reinterpret_cast) :

Code :

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

1
2
3
4
5
/* en reprennant le bout de code précédent : */
Functor* Foncteur = &F;
 
/* pour l'utiliser : */
(reinterpret_cast<Function<void()>*>(Foncteur))()

Voila, j'espère avoir été assez clair. Est-ce que vous auriez une solution pour stocker ces foncteurs ?

Merci d'avance.

[Davidbrcz]

ne réinvente pas la roue !
regarde du coté de boost::function ou de <tr1/functional>

[xwindoo]

Certes je réinvente un peu la roue

J'ai déjà regardé du coté de boost; mais je n'ai pas trouvé comment réaliser ce que je souhaite faire. A ma connaissance, on utilise boost.function à peu près de la même manière que mes foncteurs, à savoir qu'on met la signature de la fonction en paramètre template. C'est juste ?

Sinon <tr1/functional> je ne connais pas; comment l'utilise-t-on ?

[tnarol]

Sans préjuger de l'existence d'une bonne solution j'ai personnellement l'impression que l'abstraction nécessaire au stockage ne fait pas bon ménage avec la spécialisation introduite par les templates. J'aurais tendance à dire qu'il faut abandonner un des deux. Par exemple si tu limite la capacité de spécialisation à un nombre limité de triplets <class R, class T1, class C> alors tu pourrais définir des fonctions virtuelles operator() correspondantes au niveau de ta classe mère et faire l'appel que tu souhaite...mais c'est vraiment pas très élégant.

[xwindoo]

Je ne suis pas sur d'avoir compris. Peux-tu me donner un exemple ?

En gros je devrais créer autant de fonctions virtuelles operator () dans la classe mère que de spécialisations ?

[tnarol]

Je ne suis pas sur d'avoir compris. Peux-tu me donner un exemple ?

En gros je devrais créer autant de fonctions virtuelles operator () dans la classe mère que de spécialisations ?

Oui c'est ça...tu vas me dire que c'est pourri et tu auras raison...

[xwindoo]

Non ce n'est pas pourri, j'y avais pensé d'ailleurs.
Mais y'a un problème qui se pose :

que met on en paramètre de retour ? Par exemple :

Code :

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

1
2
3
4
class Functor
{
    virtual ??? operator()();
};

pour que les fonctions virtuelles soient adaptées à tous les types de fonctions, il faudrait rajouter un paramètre template :

Code :

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

1
2
3
4
5
template <class R>
class Functor
{
    virtual R operator ()();
};

Et dans ce cas on retombe à la case départ : on pourra pas stocker des foncteurs de types de retour différents. Et ce, pareil pour les paramètres.

Merci quand même pour ta réponse

[Mat.M]

Et dans ce cas on retombe à la case départ : on pourra pas stocker des foncteurs de types de retour différents. Et ce, pareil pour les paramètres.

Pourquoi veux-tu mettre des pointeurs de fonctions dans une std::list ?
Sais-tu ce que c'est qu'un pointeur ? Sous Windows par exemple c'est un DWORD de 4 octets ou adresse mémoire 32bits..
En fonction de cela et par conséquent si tu as un pointeur sur une fonction à une adresse xxxxx, il se peut fortement que l'OS déplace l'exécutable ou le process en mémoire et ton adresse xxxx n'est plus du tout valide.
Donc ta std::list ne sera plus valide et tu risques d'avoir des plantages...
Quel est le but final du projet que veux-tu faire ?

[Davidbrcz]

Voici un code qui illustre mon propos:

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
 
#include <iostream>
#include <vector>
#include <boost/function.hpp>
#include <boost/bind.hpp>
 
struct Fct
{
    Fct(int ii):m_i(ii){}
    int foo(int num){return m_i*num+5;}
private:
    int m_i;
};
 
int affine(int num)
{
    return (2*num+1);
}
 
int affine2(int num)
{
    return (4*num-2);
}
 
int main(int argc, char const **argv)
{
    Fct fct(10);
 
    std::vector< boost::function1<int, int> > vec;
 
    vec.push_back(affine);
    vec.push_back(affine2);
    vec.push_back( boost::bind(&Fct::foo,fct,_1) );
 
    const int k=vec.size();
    for(int i=0;i<k;i++)
	std::cout<<vec[i](42)<<std::endl;
 
    return 0;
}

La seule limitation de ce code dans la signature de la fonction. Dans mon exemple, il faut que la fonction renvoit un int après en avoir prit un en paramètre.

[xwindoo]

Merci pour cette précision.

Cette seule limitation est justement celle qui me gène. Je voudrai stocker des foncteurs renvoyant des types différents avec des paramètres différents.