Pointeur de fonction de membre surchargé sur le modèle

Vous pouvez essayer explicitement le pointeur, pour le faire savoir lequel choisir, comme celui-ci: XXX

Disclaimer: Je n'ai pas testé

Ceci fonctionne,

    typedef void (GApp::*MemberFunctionType)(double); 
    MemberFunctionType pointer = &GApp::foo;


  connect(MemberFunctionType);

Votre code comme écrit ne compile pas. J'ai fait des "hypothèses" sur ce que vous vouliez faire et j'ai changé le code.

Pour résumer, vous pouvez appeler la fonction correcte en spécifiant explicitement le type de paramètre de fonction: P>

template <class Arg = void>
class signal {};
signal<double> signal_double;
signal<> signal_void;

// Arg1 is deduced from signal<Arg1> and then we use it in the declaration
// of the pointer to member function
template<class T, class Arg1>
void connect ( signal<Arg1>& sig, T& obj, void (T::*f)(Arg1) ) {}

// Add special case for 'void' without any arguments
template<class T>
void connect (signal<> & sig, T& obj, void (T::*f)()) {}


void bar ()
{
  GApp myGApp;

  //Connecting foo()
  connect(signal_void, myGApp, &GApp::foo); // Matches second overload

  //Connecting foo(double)
  connect(signal_double, myGApp, &GApp::foo); // Matches first overload
}

Utilisation de boost :: Bibliothèque de fonctions ...

#include <boost/function.hpp>

template<class Arg1>
void connect(boost::function1<void, Arg1*> fn) 
{
    //Do some stuff
}

template<class Arg1>
void connect(boost::function2<void, Arg1*, double> fn) 
{
    //Do some stuff
}

class GApp
{
public:
    void foo() {}

    void foo(double d) {}
};


int main()
{
    boost::function1<void,GApp*> f1 = (void (GApp::*)(void)) &GApp::foo;
    boost::function2<void,GApp*,double> f2 = (void (GApp::*)(double)) &GApp:foo;
    connect(f1);
    connect(f2);
    return 0;
}

Mon code d'origine est comme celui-ci,

connecteurs .... xxx

signaux ... xxx < p> application ... xxx

finaly, connexion ... xxx

Il y a des classes de modèle pour les signaux (qui ne sont pas mentionnés ici). J'espère que c'est plus clair la situation. (ou est-ce comme précédent?). Cette deuxième connexion fonctionnera s'il n'y a pas de FOO () (seulement FOO (double)). C'est la chose que mon code me fait mal. : (

Le langage de programmation C ++, 3e, section 7.7, P159:

Vous pouvez prendre l'adresse d'une fonction surchargée en attribuant ou initialise un pointeur à fonctionner. Dans ce cas, le type de cible est utilisé pour sélectionner dans l'ensemble des fonctions surchargées. Par exemple: xxx

autant que je sache (je n'ai pas vérifié), il en va de même pour les fonctions membres. La solution est donc probablement à scinder sur deux lignes: xxx

devient: xxx

ne jamais appeler variables TMP ; -)

Je suppose que le casting de Newacct est également en sécurité, car exactement la même raison. Casting à Void (Gapp :: *) (Double) est défini comme étant identique à l'initialisation d'un type temporaire de type Void (gapp :: *) (double) . Étant donné que l'expression utilisée pour initialiser est & gapp: FOO , je m'attendrais à ce que la même magie soit appliquée à la distribution telle que s'applique à toute autre initialisation avec une fonction surchargée. STROSTRUP ne dit pas "initialiser une variable de pointeur à fonction", dit-il "initialisation d'un pointeur à fonction". Donc, cela devrait inclure des temporaires.

Donc, si vous préférez une doublure: xxx

Cependant, je suppose que la norme a la même idée de la consistance que je le fais, et je n'ai pas vérifié.