Partial specialization for member functions template arguments?

Question

Partial specialization for member functions template arguments is possible? I'm not sure, but it is worth a try. This works just fine (http://coliru.stacked-crooked.com/a/795e953af7537ab6):

#include <iostream>

struct Foo { void Bar() { std::cout << "Bar()" << std::endl; } };
struct Foo2 { void Bar2() { std::cout << "Bar2()" << std::endl; } };

template <typename TClass, void(TClass::*t_func)()>
void function()
{
    TClass p;
    (p.*t_func)();
}

template <typename TClass, void(TClass::*t_func)(), typename TClass2, void(TClass2::*t_func2)(), typename ...Rest>
void function()
{
    function<TClass, t_func>();
    function<TClass2, t_func2, Rest...>();
}

int main()
{
    function<Foo, &Foo::Bar, Foo2, &Foo2::Bar2>();
}

Output:

Bar()
Bar2()

The next sample also works (http://coliru.stacked-crooked.com/a/e8fe14dde6932f4c):

#include <iostream>

struct Foo { Foo() { std::cout << "Foo()" << std::endl; } };
struct Foo2 { Foo2() { std::cout << "Foo2()" << std::endl; } };

template <typename... Args>
struct Impl;

template <typename TClass, typename ...Rest>
struct Impl<TClass, Rest...>
{
    static void function()
    {
        TClass p;
        Impl<Rest...>::function();
    }
};

template <>
struct Impl<>
{
    static void function(){ std::cout << "EmptyImpl" << std::endl; }
};

template <typename ...Args>
struct Factory
{
    Factory()
    {
        Impl<Args...>::function();
    }
};

int main()
{
    auto f = Factory<Foo, Foo2>();
}

Output:

Foo()
Foo2()
EmptyImpl

But if I want to combine these two things above:

#include <iostream>

struct Foo { void Bar() { std::cout << "Bar()" << std::endl; } };
struct Foo2 { void Bar2() { std::cout << "Bar2()" << std::endl; } };

template <typename... Args>
struct Impl;

template <typename TClass, void(TClass::*t_func)(), typename ...Rest>
struct Impl<TClass, decltype(t_func), Rest...>
{
    static void function()
    {
        TClass p;
        Impl<Rest...>::function();
    }
};

template <>
struct Impl<>
{
    static void function(){}
};

template <typename ...Args>
struct Factory
{
    Factory()
    {
        Impl<Args...>::function();
    }
};

int main()
{
    auto f = Factory<Foo, &Foo::Bar, Foo2, &Foo2::Bar2>();
}

it will be a compiler error:

main.cpp: In function 'int main()':
main.cpp:36:59: error: type/value mismatch at argument 1 in template parameter list for 'template<class ... Args> struct Factory'
         auto f = Factory<Foo, &Foo::Bar, Foo2, &Foo2::Bar2>();
main.cpp:36:59: note:   expected a type, got '&Foo::Bar'
main.cpp:36:59: error: type/value mismatch at argument 1 in template parameter list for 'template<class ... Args> struct Factory'
main.cpp:36:59: note:   expected a type, got '&Foo2::Bar2'

Any idea? What did I miss? :)

Answer 1

consider using additional wrapper for calling member functions

#include <iostream>

struct Foo { void Bar() { std::cout << "Bar()" << std::endl; } };
struct Foo2 { void Bar2() { std::cout << "Bar2()" << std::endl; } };

template <class TClass>
using FType = void(TClass::*)();

template<class TClass, FType<TClass> t_func>
class Caller
{
public:
  Caller()
  {
    TClass p;
    (p.*t_func)();
  }
};

template <typename... Args>
struct Impl;

template <class TClass, typename ...Rest>
struct Impl<TClass, Rest...>
{
    static void function()
    {
        TClass p;
        Impl<Rest...>::function();
    }
};


template <>
struct Impl<>
{
    static void function(){}
};

template <class ...Args>
struct Factory
{
    Factory()
    {
        Impl<Args...>::function();
    }
};

int main()
{
    auto f = Factory<Caller<Foo, &Foo::Bar>, Caller<Foo2, &Foo2::Bar2> >();
}