C++

Templates et pointeurs de fonctions membres?

Recherche :

Mot : Pseudo : Filtrer
Page : 1 2 Page Suivante Page Précédente Bas de page
Auteur	Sujet : Templates et pointeurs de fonctions membres?

peak

Salut tout le monde;

Je me demandais si les templates pouvaient recevoir comme type des pointeurs de fonctions membres?
Si c'est le cas je ne comprend pas pourquoi ceci ne marche pas :

J'essaye en fait de donner un pointeur de fonction membre d'un objet quelconque à un ActionListener pour pouvoir ensuite donner à un controller des pointeurs de fonctions membres d'ActionListener
J'ai cru en être obligé de faire ça du fait que les types de fonctions membres d'objets différents sont incompatibles.

(si existe des types de pointeur de fonction membres dobjet « void » ça mintéresse aussi )

J'improvise c'est peu êter pas comme ça qu'il faut qu'il faut s'y prendre pour implémenter un controller mais bon si ce problème est résolut ça devrai marcher.

Code :

//pointeurs de fonction membre de test
typedef void (Test::*ptr_TestFunc) (int, int, int);
//...
//pointeur de fonction membre d'ActionListener
template<class ptrMethode>
typedef void (ActionListener<ptrMethode>::*ptr_ActionListenerFunc) (int, int, int);
//Class ActionListener
template<class ptrMethode>
class ActionListener{
ActionType type;
ptrMethode action;
public:
//constructeur
ActionListener(ActionType _type, ptrMethode _action): type(_type), action(_action){}
void actionPerformed(int key, int x, int y) { cout<<"Call methode"<<endl; action(key, x, y)}
};
//....
//le problème se pose ici
button1->addActionListener(new ActionListener<ptr_TestFunc>(KeyEvent, buttonKeyEventActionPreformed));

error C2440: 'initializing' : cannot convert from 'class ActionListener<void (__thiscall Test::*)(int,int,int)> *' to 'class ActionListener<ptrMethode> *'

Ce qui m'inquiète c'est que dans le message d'erreur le template est pas interprété.

Si vous avez des conseil, avis ils sont les bienvenu...
:bounce:

Message édité par peak le 08-11-2004 à 23:18:18

Publicité

schnapsmann

Zaford Beeblefect

et si tu nous donnais le code de ta classe composant (methode addActionListener) ?

---------------
From now on, you will speak only when spoken to, and the first and last words out of your filthy sewers will be "Sir!"

peak

oui, désolé,

Code :

template<class ptrMethode>
typedef ActionListener<ptrMethode> *ptr_ActionListener;
//...
void Component::addActionListener(ptr_ActionListener p_action_list){
cout<<"Component::addActionListener"<<endl;
}

Message édité par peak le 08-11-2004 à 23:56:09

Taz

bisounours-codeur

moi je comprends pas ce que tu fais, ni où est le problème. Alors je te dirais tout simplement de tout virer.

Fais une classe template<typename Functor>
un membre Functor initialisé dans le constructeur
dans ta actionPerformed, tu fais un gros this->func(a, b, c)

et tu rajoutes un sucre syntaxique : une fonction qui crée les instances pour faire marcher la déduction de type

Taz

bisounours-codeur

new ActionListener<ptr_TestFunc>(KeyEvent, buttonKeyEventActionPreformed

je vois pas comment ton truc ça peut marche, les différentes instances template d'ActionListener n'ont aucun lien de parenté, à part void*, tu peux rien en faire

peak

ok, cool, en fait c'est plus ou moins ce que j'avais voulu faire.
Et ça m'arrange bien que tu me dises que y'ai moyen par ce que je commençais à me dire que je voyais vraiment pas comment faire autrement.

Mais donc ici dans mon ActionListener je devrai pouvoir chopper un pointeur de fonction membre de test, donc je capte pas pourquoi ça passe pas!

En fait c'est l'initialisation d'ActionListener qui plante:

Code :

new ActionListener<ptr_TestFunc>(KeyEvent, buttonKeyEventActionPreformed)

peak

ha merde je viens de voir le message au dessus :ange:

Message édité par peak le 09-11-2004 à 00:11:33

peak

Taz a écrit :

les différentes instances template d'ActionListener n'ont aucun lien de parenté, à part void*, tu peux rien en faire

Ben j'ai pas trop compris en fait.
Je veux juste donné un pointeur de fonction membre d'object quelcquonque au constructeur d'ActionListener.
Mais il veut rien savoir...

Taz

bisounours-codeur

c'est le addActionListener qui chie déjà, le reste je sais pas. c'est quoi le prototype de ton addActionListener ?

message d'erreur de compilation ?

toutes façons, ton code foire, tu manipules les pointeurs de fonctions n'importe comment. Apprends à les utilser, ou passe à une approche toute template.

Taz

bisounours-codeur

Code :

template<typename T, typename RET, typename ARG>
RET invoke(T &self, RET (T::*p)(ARG), ARG arg)
{
return (self.*p)(arg);
}
class Foo
{
public:
float f(int);
bool g(bool);
bool h(Foo);
bool i(Foo *);
};
void test()
{
Foo f;
invoke(f, &Foo::f, 3);
invoke(f, &Foo::g, true);
invoke(f, &Foo::h, Foo());
invoke(f, &Foo::i, static_cast<Foo*>(0));
}

une version typée pas template, ça serait ça.

Publicité

peak

pour le protoype :
void addActionListener(ptr_ActionListener );

et le message d'erreur :
error C2440: 'initializing' : cannot convert from 'class ActionListener<void (__thiscall Test::*)(int,int,int)> *' to 'class ActionListener<ptrMethode> *'

moi je me disais que c'était peu être à cause de

//pointeur de fonction d'ActionListener
template<class ptrMethode>
typedef ActionListener<ptrMethode> *ptr_ActionListener;

par ce que dans le message d'erreur le compilateur à pas l'aire d'interpreter le template?

Message édité par peak le 09-11-2004 à 01:21:04

peak

ok parfait je vais tester ça!
Merci

Taz

bisounours-codeur

je sais pas, je comprends rien à ta boue, t'as toujours pas filé un seul morceau de code complet.

Taz

bisounours-codeur

on peut jouer à l'infini

Code :

#include <functional>
namespace
{
struct ActionListenerBase : std::unary_function<void, int>
{
virtual void operator()(const int & ) =0;
virtual ~ActionListenerBase() { }
};
}
template<typename T>
class ActionListener : ActionListenerBase
{
T functor;
public:
ActionListener(const T &t) : functor(t) { }
void operator()(const int &x) { return functor(x); }
};
#include <queue>
#include <boost/shared_ptr.hpp>
class Foo
{
typedef boost::shared_ptr<ActionListenerBase*> Listener;
std::queue<Listener> listeners;
public:
template<typename T>
void add_action_listener(const ActionListener<T> &al)
{
this->listeners.push_back(new ActionListener<T>(al));
}
};

pour pouvoir foutre dedans tous ce qui permet d'écrire 'x(i)' retournant 'void'.

À voir aussi chez boost (pour ne pas réinventer la roue)
http://www.boost.org/doc/html/function.html && http://www.boost.org/libs/bind/bind.html (fantastiques)

Pour rester plus classique et faire sauter les limitations de STL
http://www.boost.org/libs/bind/mem_fn.html (généralisation/correction de STL)
http://www.boost.org/libs/functional/index.html (généralisation/correction de STL)

el muchacho

Comfortably Numb

En cadeau la définition des foncteurs généralisés d'A. Alexandrescu dans le livre "Modern C++ design".

L'auteur commence par définir un container de types calqué sur une liste façon Lisp, qu'il appelle Typelist. La version courte en est :

Code :

// Fichier TypeList.h
class NullType {};
template <class T, class U>
struct TypeList
{
typedef T Head;
typedef U Tail;
}
#define TYPELIST_1(T1) TypeList<T1, NullType>
#define TYPELIST_2(T1, T2) TypeList<T1, TYPELIST_1(T2)>
#define TYPELIST_3(T1, T2, T3) TypeList<T1, TYPELIST_2(T2, T3)>
// ... ad infinitum
// on peut allors faire, par exemple :
typedef TYPELIST_3(short int, int, long int) EntiersSignes;

Dans la version longue, l'auteur définit tout un tas d'opérations sur les listes de types ainsi créées, comme le calcul de la longueur, un accès indexé, une opération de concaténation, de recherche, etc, opérations entièrement résolues à la compilation. Tout ça est pratique lorsqu'on veut définir des classes ou des fonctions avec un nombre variable de paramètres et des types indéterminés.

Ici on va se servir est l'accès indexé : on donne un index dans la liste et ça retourne le type correspondant:

Code :

// index 0
template <class Head, class Tail>
struct TypeAt<TypeList<Head, Tail>, 0> {
typedef Head Result;
};
// index i non nul. Notez la récursivité ;)
template <class Head, class Tail, unsigned char i>
struct TypeAt<TypeList<Head, Tail>, i> {
typedef typename TypeAt<Tail, i-1>::Result Result;
};

Ainsi TypeAt<EntiersSignes, 2> retourne le type long int.

Maintenant venons-en aux foncteurs proprement dits :

Code :

// Fichier Functor.h
#include <auto_ptr>
#include "TypeList.h"
//ParamList est un TypeList qui contient les parametres d'entrée
// et Ret le retour de la fonction
template <typename Ret>
class FunctorImpl <Ret, NullType>
{
virtual Ret operator()() = 0;
virtual FunctorImpl* clone() const = 0;
virtual ~FunctorImpl() {}
};
template <typename Ret, typename p1>
class FunctorImpl <Ret, TYPELIST_1(p1)>
{
virtual Ret operator()(p1) = 0;
virtual FunctorImpl* clone() const = 0;
virtual ~FunctorImpl() {}
};
template <typename Ret, typename p1, typename p2>
class FunctorImpl <Ret, TYPELIST_2(p1, p2)>
{
virtual Ret operator()(p1, p2) = 0;
virtual FunctorImpl* clone() const = 0;
virtual ~FunctorImpl() {}
};
// ...
// classe concrete dérivée de FunctorImpl
template <class ParentFunctor, typename fun>
class FunctorHandler : FunctorImpl
<typename ParentFunctor::ResultType,
typename ParentFunctor::ParamList>
{
public:
typedef typename ParentFunctor::ResultType ResultType;
FunctorHandler(const Fun& fun) : fun_(fun) {}
FunctorHandler* clone() const {return new FunctorHandler(*this);}
ResultType operator()() {return fun_();}
ResultType operator()(typename ParentFunctor::Param1 p1) {
return fun_(p1);
}
ResultType operator()(typename ParentFunctor::Param1 p1,
typename ParentFunctor::Param1 p2) {
return fun_(p1, p2);
}
// ...
private:
Fun fun_;
}
template <typename Ret, class ParamList = NullType>
class Functor
{
typedef FunctorImpl<Ret, ParamList> Impl;
typedef typename TypeAt<ParamList, 0>::Result Param1;
typedef typename TypeAt<ParamList, 1>::Result Param2;
typedef typename TypeAt<ParamList, 2>::Result Param3;
// ...
public:
Functor() : pImpl_(0) {}
Functor(const Functor &rhs) : pImpl_(Impl::clone(rhs.pImpl_.get())) {}
Functor& operator=(const Functor &rhs) {
Functor copy(rhs);
// swap auto_ptrs by hand
Impl* p = pImpl_.release();
pImpl_.reset(copy.pImpl_.release());
copy.pImpl_.reset(p);
return *this;
}
Functor(std::auto_ptr<Impl> pImpl) : pImpl_(pImpl) {}
Ret operator()() {return (*pImpl_)();}
Ret operator()(Param1 p1) {return (*pImpl_)(p1);}
Ret operator()(Param1 p1, Param2 p2) {return (*pImpl_)(p1, p2);}
Ret operator()(Param1 p1, Param2 p2, Param3 p3) {return (*pImpl_)(p1, p2, p3);}
// etc
private:
std::auto_ptr<Impl> pImpl_;
}

Ca, c'est la version courte. [:itm]

A l'utilisation, ça donne:

Code :

#include "TypeList.h"
#include "Functor.h"
#include <iostram>
using namespace std;
struct FoncteurTest {
void operator()(int i, double d) {
cout << "FoncteurTest::operator()(" << i << ", " << d << " ).\n";
}
};
int main()
{
FoncteurTest f;
Functor<void, TYPELIST_2(int, double)> cmd(f);
cmd(4, 3.14);
}

Message édité par el muchacho le 10-11-2004 à 17:10:47

Taz

bisounours-codeur

ouais ouais, boost::tuple pour la listequoi, boost toujours, boost vaincra !

explicit Functor(std::auto_ptr<Impl> spImpl);
par contre ça c'est bidon, vu le transfert de propriété

el muchacho

Comfortably Numb

'fectivement, boost::tuple fait la même chose. D'ailleurs je ne serais pas étonné que boost::tuple soit inspiré de l'implémentation d'Alexandrescu dans Loki. C'est pourquoi la lib Loki d'Alexandrescu est un du coup un peu obsolète (c'est ce que j'ai mis dans mon CR de lecture dans le post ad'hoc), mais le bouquin permet de comprendre les choses.

Message édité par el muchacho le 09-11-2004 à 10:29:28

Taz

bisounours-codeur

bah Alexandrescu a rien inventé
et sans jamais l'avoir vu, tu très bien retrouvé ce genre de CRTP tout seul

el muchacho

Comfortably Numb

M'ouais, si j'ai du temps à perdre, quoi. [:spamafote]

Taz

bisounours-codeur

quoi ?

peak

Je suis en train de méditer sur vos post très instructifs (merci).
Je commence à y voir plus claire même si tout est loin d'être limpide.
:ange:

Par exemple dans la version de Taz je ne comprend pas pourquoi ceci me donne ce message d'erreur?

error C2664: '__thiscall ActionListener<void (__thiscall Test::*)(int)>::ActionListener<void (__thiscall Test::*)(int)>(void (__thiscall Test::*const & )(int))' : cannot convert parameter 1 fro
m 'void (int)' to 'void (__thiscall Test::*const & )(int)'

C 'est comme si il considerait pas ma fonction "clickButtonActionPreformed" comme une fonction membre de Test :heink:

Code :

class Test;
typedef void (Test::*TestFunctor) (int);
class Test{
public:
Foo f1;
Test(){
ActionListener<TestFunctor> al(clickButtonActionPreformed);
}
void clickButtonActionPreformed(int );
};
void Test::clickButtonActionPreformed(int val){
cout<<"clickbutton"<<endl;
}
void main(){
Test t1;
}

Taz

bisounours-codeur

t'as rien compris ... &Test:: à la limite, mais ce n'est pas là l'usage qu'il faut en faire. Toute façon tu n'iras pas plus loin

T'es complètement perdu ... commence par voir comment on se sert d'un pointeur de fonction membre. Là t'en chie, alors je te file des pistes pour des cas génériques. Des liens pour tout planquer, ça passe comme une lettre à la poste, mais t'as pas l'air d'être intéressé par les liens ...

Message édité par Taz le 09-11-2004 à 11:31:44

peak

sisi, c juste que je pensais que le ... &Test:: était implicite et que ça pourrait marcher comme ça...

edit: ceci dis c'est vrai que je suis un peu paumé

Message édité par peak le 09-11-2004 à 11:40:50

Taz

bisounours-codeur

ISO C++ interdit de prendre l'adress d'un membre de fonction non statique non qualifié ou entre parenthèses pour former un pointeur d'un membre de fonction. Utilisers «&Test::clickButtonActionPreformed»

peak

Pour le deuxième exemple de Taz, mon compilo apprecie pas le push_back dans un vector :

'push_back' : cannot convert parameter 1 from 'class ActionListener<void (__thiscall Test::*)(int)> *' to 'const class boost::shared_ptr<struct `anonymous namespace'::ActionListene
rBase *> &'

J'avais cru comprendre que "boost:shared_ptr"
servais justement à eviter ça; mais apparement j'ai du encore me planter :pfff:

(en passant je me demandais aussi pourquoi on utilisait un namespace anonyme pour ActionListenerBase?)

Taz

bisounours-codeur

compilateur de merde

peak

lol,
je compile avec visual par ce que j'ai commencé mon projet avec mais la prochaine étape (apres l'API) c'tai de porter le code sous g++...en attendant vous avez une idée d'une solution temporaire?

Au pire je pense pouvoir utiliser des poiteurs void à la place de références d'ActionListener... je vais tester ça ...

el muchacho

Comfortably Numb

Si t'es sous VC7.1, en principe ça devrait passer, si t'es sous VC6, tu peux oublier Boost.

peak

j'ai pas de bol aujourd'hui! J'ai VC6.
Mais merci c'est bon à savoir; si je ne trouve pas de solution je m'arrangerai pour me le procurer.

el muchacho

Comfortably Numb

Et ma solution ? A défaut de Boost, tu peux quand même utiliser Loki, qui est quand même puissant, et qui a été porté sur VC6.

Message édité par el muchacho le 09-11-2004 à 19:19:59

Taz

bisounours-codeur

autant utiliser boost::function, c'est beaucoup meilleur à toutes nos sortes de hack.

Mais le problème, c'est la conception : si tu veux avoir une collection hétérogène d'objets callbacks, il faut que tu définies une interface, etc

el muchacho

Comfortably Numb

Taz a écrit :

autant utiliser boost::function, c'est beaucoup meilleur à toutes nos sortes de hack.

Mais le problème, c'est la conception : si tu veux avoir une collection hétérogène d'objets callbacks, il faut que tu définies une interface, etc

Houlala, ton français s'améliore de jour en jour. Et il est sous VC6, on a dit.

Message édité par el muchacho le 09-11-2004 à 19:23:27

Taz

bisounours-codeur

c'est un peu fait exprès

et je sais pas, y a beaucoup de bricolage dans boost pour que ça marche avec VC6, faudrait voir à quand même essayer.

Moi je pense que t'es pas prêt pour les template. Commence à comprendre comment ça fonctionne les pointeurs de fonctions membres, fait du polymorphisme et voilà

Message édité par Taz le 09-11-2004 à 19:57:33

peak

Je vais suivre vos conseils... en tous cas j'ai appris pas mal de trucs...merci bien!

Ps : j'ai un solution qui m'a quand même l'aire pas trop mal; je ne donne finalement à mon controller que des pointeurs de fonctions membres d'actionListener (pas d'actionListener) et ai apparement plus besoin de template...je fait en suite une liste de pointeurs de fonctions membres d'ActionListener dans mon controller (et bon là j'ai encore un tit prob mais bon ça devrait être arrangeable)

A+

Taz

bisounours-codeur

t'as bien compris la syntaxe d'appel etc ?

peak

Je pense que ça ça devrait aller (avec quelques tests)... par contre je viens de passer une heure à pas comprendre pourquoi si j'ai un tableau static de pointeurs de fonctions membres d'ActionListener et que je l'initialise avec :

ActionListenerFunctor** Controller::actions(NULL);

il veut rien savoir alors que si je lui donne pas de valeur :

ActionListenerFunctor** Controller::actions;

il passe et le considère comme assigné à NULL mais bon je sors un peu du sujet du topic là .... :sweat:

Taz

bisounours-codeur

static ?

utilise l'initialisation par copie (= 0);

mais pourquoi ne pas utiliser un vector ?

LeGreg

Passe à VC7 en plus c'est gratuit:
http://msdn.microsoft.com/visualc/vctoolkit2003/

el muchacho

Comfortably Numb

Quelques corrections dans le code que j'ai donné (attention, non testé, mais l'essentiel y est).

peak

Ma première idée c'était de faire un

static std::vector<ActionListenerFunctor*> actions[NBR_ACTION_TYPES];

En fait chaque composants de l'API a une table dans laquelle il garde ses pointeurs et il passe au controller l'adress de l'entré de sa table pour pouvoir

gérer ses pointeur localement et changer de fonction puis effacer l'enter à la destruction du composant.

Mais j'ai un
error C2036: 'class std::vector<void (__thiscall ActionListener<_Ty>::**)(int,int,int),class std::allocator<void (__thiscall

ActionListener<_Ty>::**)(int,int,int)> > *' : unknown size
//d'ailleur malgré la doc je comprend pas trop cette erreur dans mon cas
et plus chiant ;
error C2662: 'push_back' : cannot convert 'this' pointer from 'class std::vector<void (__thiscall ActionListener<_Ty>::**)(int,int,int),class
std::allocator<void (__thiscall ActionListener<_Ty>::**)(int,int,int)> >' to 'class std::vector<_Ty,_A> &'

donc je m'était dis qu'un matrice ferait l'affaire ...
Mais évidement ça pouvais pas simplement marcher donc j'ai un problème d'allocation complètement débile; le compilateur ne détecte pas d'erreur mais dans le constructeur de Controller quand je fait :

Code :

//...
ActionListenerFunctor** Controller::actions;
//j'ai simplifier l'histoire de la table locale le temps que ça marche
//sinon j'aurai ActionListenerFunctor*** Controller::actions;
Controller() {
if(actions==NULL){
actions=new ActionListenerFunctor* [NBR_ACTION_TYPES];
for(unsigned i=0; i<NBR_ACTION_TYPES; i++){
actions[i]=new ActionListenerFunctor [INIT_CONTOLLER_LENGHT];
for(unsigned j=0; j<INIT_CONTOLLER_LENGHT; j++){
cout<<&actions[i][j]<<endl;
actions[i][j]=NULL;
}
}
}
}

si #define INIT_CONTOLLER_LENGHT 6 no prob
si #define INIT_CONTOLLER_LENGHT 7 no prob
si #define INIT_CONTOLLER_LENGHT 8 segmentation fault!?

0x049B1D30
0x049B1D38
0x049B1D40
0x049B1D48
0x049B1D50
0x049B1D58
0x049B1D60
0x00000038 plantage!

A croire que j'ai offensé le tout puissant par ce que là je vois pas le rapport !?

Sinon je met dans les pages de man qu'on peux pas avoir plus que 6compossants et que faudra attendre la version 2.0 mais je commence à fortement douter que mon projet révolutionne le monde de linformatique ce qui était pourtant ça vocation première...

LeGreg :
Passe à VC7 en plus c'est gratuit:
http://msdn.microsoft.com/visualc/vctoolkit2003/

Ha tiens je savais pas que c'était gratuit je vais tester ça!, mais d'abord finir 2-3 autres details (style aujourd'hui je dois absolument commenter (j'ai 3000lignes du proj sans un comment) ... sans doute le truc le plus chiant de la semaine d'ailleurs...)

Publicité

Page : 1 2

Page Suivante

Page Précédente

Haut de page

FORUM HardWare.fr

Programmation

C++

Templates et pointeurs de fonctions membres?

Sujets relatifs
question sur les fonctions virtuelles	Question pointeurs
debug : evolution des pointeurs	[Ada] Fonctions de manipulation de Strings
Lire les fonctions d'une dll	Limite de taille dans les arguments de fonctions
excel - aide sur des fonctions	pb de sessions/fonctions
Comment créer des fonctions PL/SQL	fonctions et image
Plus de sujets relatifs à : Templates et pointeurs de fonctions membres?

Page générée en 0.146 secondes