problème de pointeur de fonction réécrite à la classe de base modèle C++

Question

I mis en œuvre une classe de base de modèle pour motif d'observateur,

template<class T> 
class ActionListener 
{ 
public: 
    ActionListener(void);  
    virtual ~ActionListener(void);  
    void registerListener(T* listener);  
    void unregisterListener(T* listener); 

    template<typename Signal> 
    void emit(Signal signal); 

    template<typename Signal, typename Parameter> 
    void emit(Signal signal, const Parameter& parameter); 

    template<typename Signal, typename Parameter1, typename Parameter2> 
    void emit(Signal signal, 
       const Parameter1& parameter1, 
       const Parameter2& parameter2); 

private: 
    std::vector<T*> mListenerList; 
}; 

class IEventListener 
{ 
public: 
    virtual void messageArrived(Message* message); 
    virtual void messageArrived(ClientHandle* handle, Message* message); 
}; 

je suis en utilisant des cours comme celui-ci

emit(&IEventListener::messageArrived, message); 
emit(&IEventListener::messageArrived, mHandle, message); 

le problème est ici, le compilateur ne peut pas en déduire paramètres de modèle et je ne pouvais pas donner des paramètres de modèle explicitement?

Est-ce que quelqu'un a une idée?

EDIT: La fonction "Émettre" fonctionne correctement pour les autres types de fonctions.

L'utilisation de ce modèle est

class SampleClass : public ActionListener<IEventListener> 
{ 
//some stuff here 
//this class is observing events of IEventListener 
} 

par la façon dont cela est C++.

Answer 1

IEventListener::messageArrived est surchargée, de sorte que le compilateur ne peut pas déterminer le type de &IEventListener::messageArrived. Il pourrait être void (IEventListener::*)(Message*) ou void (IEventListener::*)(ClientHandle*, Message*).

Le straighforward (et laid) solution consiste à couler explicitement &IEventListener::messageArrived au type désiré au niveau du site d'appel, comme ceci:

emit(static_cast<void (IEventListener::*)(Message*)>(&IEventListener::messageArrived), a_message_ptr); 

ou en affectant à une variable de type fonction désirée:

void (IEventListener::*func_ptr)(Message*) = &IEventListener::messageArrived; 
emit(func_ptr, a_message_ptr); 

(Ai-je dit qu'il était laid?)

pourrait aussi être spécifié explicitement paramètre de modèle:

emit<void (IEventListener::*)(Message*)>(&IEventListener::messageArrived, a_message_ptr); 

(toujours laid)

Une autre solution imparfaite est de déduire le type de Signal du type de l'auditeur (T) et les autres paramètres:

// Warning: untested. 
// For illustration purposes only 
template<class T> 
class ActionListener 
{ 
public: 
    //... 
    void emit(void (T::*signal)()); 

    template<class Arg1T> 
    void emit(void (T::*signal)(Arg1T), Arg1T); 

    template<class Arg1T, class Arg2T> 
    void emit(void (T::*signal)(Arg1T, Arg2T), Arg1T, Arg2T); 
}; 

Ceci est imparfait mais parce que les types d'arguments doivent correspondre exactement.

Selon la quantité de changements que vous pouvez apporter à la conception, une solution plus simple consisterait à supprimer l'ambiguïté en attribuant des noms différents aux membres de IEventListener. Vous pouvez également utiliser une bibliothèque de signaux/emplacements déjà existante, comme Boost.Signals2

Answer 2

Je suis un peu confus au sujet de votre exemple, vous appelez

emit(&IEventListener::messageArrived, message); 

que je suppose est censé correspondre

template <class Signal> 
ActionListener<T>::void emit(Signal signal); 

Mais cette surcharge de emit ne prend qu'un seul paramètre, ce Pensez-vous que le paramètre &IEventListener::messageArrived est utilisé? Rappelez-vous que IEventListener est le paramètre modèle pour la classe ActionListener et non pour la fonction emit.

Quand j'ai essayé cela, il fonctionne:

ActionListener<IEventListener> al; 
Message* message = 0; 
al.emit(message);