c++ - Deducing type, when using member function pointer as template argument

Question

When I want to have member function as template argument, is there a way to templetize it without providing Caller type?

struct Foo
{
    template <typename Caller, void (Caller::*Func)(int)>
    void call(Caller * c) { (c->*Func)(6); }
};

struct Bar
{
    void start() 
    {
        Foo f;
        f.call<Bar, &Bar::printNumber>(this);
               ^^^^  
    }

    void printNumber(int i) { std::cout << i; }
};

int main ()
{
    Bar b;
    b.start();
    return 0;
}

when I try

template <void (Caller::*Func)(int), typename Caller>
void call(Caller * c) { (c->*Func)(6); }

and call it like

f.call<&Bar::printNumber>(this);

I am getting Caller is not class... error.

So, is there a way to let compiler deduce the Caller type?

Answer 1

No, not as you want it. Caller could be deduced if

1. the pointer to member function were an parameter, not a template parameter. Eg:

   template <class Caller>
   void call(Caller * c, void (Caller::*Func)(int)) { (c->*Func)(6); }
   

2. it was known beforehand. For example, you could make the call look like this:

   f.arg(this).call<&Bar::printNumber>();
   

   The call function would look similar to this:

   template <class Arg>
   struct Binder
   {
     template<void (Arg::*Func)(int)>
     void operator()() const {
       ...
     }
   };
   

   The arg function would be easy to write (in your case it would return Binder<Bar>, where Bar is deduced from this).

   Not very convenient, IMHO.