Comment implémenter une classe de template avec un membre de signal dépendant d'un template de boost?

Question

J'essaye d'implémenter une classe de modèle qui exige d'avoir un membre de signal qui dépend de l'argument de modèle. Ma première idée était de réaliser comme ce qui suit:

Une cette classe doit être utilisé comme:

class SignaledClass 
{ 
public: 
    SignaledClass(void) 
    { 
     SignalClass<int> var1(boost::bind(&SignaledClass::ReceiveINT, this)); 
     SignalClass<double> var2(boost::bind(&SignaledClass::ReceiveDOUBLE, this)); 
    } 

    void ReceiveINT(int &_val) 
    { 
     ... 
    } 

    void ReceiveDOUBLE(double &_val) 
    { 
     ... 
    } 
} 

(BTW: Je sais que cela n'a aucun sens de créer l'objet SignalClass juste à l'intérieur du constructeur, c'est juste pour comprendre mon problème.)

Il est important pour moi de réaliser un concept de type délégué avec un modèle comme paramètre de signal.

Le problème est que le code du constructeur ne fonctionne pas.

Mais j'ai trouvé une solution.

Si je précise en outre une typedef supplémentaire comme

typedef typename OnReceive::slot_type slot_type; 

et utilise ce paramètre pour le constructeur, comme

PushInputSlot(const slot_type& _slot); 

le cela fonctionne. Mais je ne sais pas vraiment pourquoi.

J'espère que quelqu'un peut m'aider.

Thanx, Frank

P.S .: Je suis nouveau sur des thats stackoverflow pourquoi je ne suis pas au courant des règles ici. Espère que je l'ai fait tout à la bonne façon ...; -) ....

Answer 1

Voici la raison pour laquelle l'ajout typename (soit directement dans l'argument constructeur ou dans un typedef supplémentaire) fonctionne:

Tout d'abord, le type OnReceive est ce que l'on appelle un "type dépendant", car il dépend du type du paramètre de modèle.

Ensuite, les modèles sont traités en deux étapes dans le compilateur: La première étape est lorsque le compilateur rencontre le texte source pour le modèle et la deuxième étape est lorsque le modèle est réellement instancié. Pendant la première étape du traitement, le compilateur tentera (devrait) de valider autant que possible que la définition du modèle est correcte, mais il rencontrera un problème en ce qui concerne les types dépendants. Comme un type dépendant dépend des paramètres du modèle, le compilateur ne sait pas à quoi ressemblera le type réel.
En particulier, lors de l'accès à un membre avec l'opérateur ::, le compilateur a besoin d'aide pour décider si le membre doit se référer à un type membre (typedef ou une classe imbriquée) ou un membre non-type (une variable, enum, etc.). Cela peut être résolu en ajoutant typename avant le nom de type (complet) si vous savez qu'il doit faire référence à un type.
L'autre endroit où le compilateur pourrait avoir un problème est la différenciation entre un membre-modèle et un membre non-modèle impliqué dans une comparaison inférieure à. Ceci est résolu en ajoutant le mot-clé template avant le nom du membre-modèle (immédiatement après l'opérateur).