petite précision sur les foncteurs

Bonjour,

Dans l'idée, je souhaiterais faire un foncteur supporté par une abstraction afin de définir une classe dans laquelle, il me suffirait de donner des entrées, des sorties et des fonctions de transfert (entrée/sortie).

les entrées et les sorties, ça va. La fonction de transfert... un peu moins. J'ai tout d'abord eu l'idée de faire des foncteurs... mais comme ils auraient tous des noms différents (des types mêmes... struct mafonction{}...)c'est pas générique.
Je pourrais mettre un void* qui pointe sur ces fonctions comme ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

template<class T, class U> class Acteur { //private : vector<T> entrees; U sortie; void* fct_transfert;   Acteur(vector<T>& IN, U OUT) {entrees=IN; sortie=OUT;}   void Fait() { sortie=fct_transfert()(entrees); }

---

...du moins il me semble.
est-ce que ça vous paraît correct?

Sinon, j'avais pensé faire un polymorphisme, la fonction de base est héritée et la fonction Fait est personnalisée. Est-ce faisable et si oui, est-ce "mieux"?

Merci d'avance.

Citation:

---

est-ce que ça vous paraît correct?

---

Non. Un pointeur void* ce n'est pas une forme magique de duck-typing.
Ce n'est qu'une adresse mémoire, cela oublie toute information de type etc.

Citation:

---

Sinon, j'avais pensé faire un polymorphisme, la fonction de base est héritée et la fonction Fait est personnalisée. Est-ce faisable et si oui, est-ce "mieux"?

---

C'est une idée.
Ce genre de choses existe déjà en mieux, c'est boost.function.

Autre idée plus performante, faire tout simplement

Code:

---

1 2 3 4 5

template<typename F> void Fait(const F& f) { sortie=f(entrees); }

---

:lol: J'me disais bien aussi que le void*, ça aurait été trop simple!

Pour boost...ben, j'ai toujours quelques soucis...faut installer, les lib et header semblent ne pas suffir...la doc est moyenne à ce sujet et du coup, j'ai pas envie de me casser la tête si on peut trouver plus simple (pour une appli dédiée)

Pour la solution proposée... ah oui, j'avais oublié les templates de fonction... ça peut en effet s'avérer utile! :D . Je vais vérifier ça en pratique!:)

Il suffit de quelques entêtes.
Sinon, c'est aussi dans TR1 : std::tr1::function.

J'ai essayé de concevoir ce truc mais j'ai un petit soucis

Donc soit :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

template<class T, class U> class Maclasse { public : vector<T> entrees; vector<U> sorties;   Maclasse(){}   template<typename F> void Fait(const F& fct) { fct(sorties, entrees); }     };

---

je construit un objet de cette classe patron en tant que <float,float>
avec par exemple

Code:

---

1 2 3 4 5 6 7

struct fctTest { float fct( vector<float>& s, vector<float>& e) { return s[0]=(e[0]+e[1])/2; } };

---

et le pb, c'est d'appeller cette fonction!
fctTest f;
org_m.Fait<fctTest>(&f.fct); ...mais en fait non

Comment tu peux appeler la fonction maintenant qu'elle est coincé dans le struct?!
...C'est pour ça que j'avais mis un simple void*...mais qui en théorie ne donne rien

EDIT... euh pardon, c'est bon, c'est

Code:

---

1 2 3 4 5 6 7 8

struct fctTest { void operator ()( vector<float>& s, vector<float>& e) const { s[0]=(e[0]+e[1])/2; } };

---

et
fctTest f;
org_m.Fait<fctTest>(f);

simplement! :oops:

Citation:

---

Envoyé par DEVfan

fctTest f;
org_m.Fait<fctTest>(f);

simplement! :oops:

---

Pour faire plus joli

Code:

---

org_m.Fait(fctTest());

---

suffirait.

Pas besoin de préciser le type des paramètres dans une fonction template si ceux-ci peuvent être déduits à partir des arguments...