将成员函数指针传递给采用带有可变参数的MFP的函数时，类型不匹配

Question

I have a template function that takes pointer to a member function of any type with any amount of arguments (but enforces some rules - it has to be void and the last argument has to be a pointer):

class Foo {
public:
    Foo() {}

    template<typename T, typename Out, typename ... In>
    void foo(T *obj, void(T::*func)(In ..., Out*)) {
        ...
    }
    ...
};

When I try to invoke the function, I get a type mismatch error:

class Bar {
public:
    Bar() {}
    void bar(int in, bool *out) {
        ...
    }
};

int main()
{
   Foo foo;
   Bar bar;

   foo.foo<Bar, bool, int>(&bar, &Bar::bar);
   ...
}

Error:

test.cpp: In function 'int main()':
test.cpp:41:44: error: no matching function to call to 'Foo::foo(Bar*, void (Bar::*)(int, bool*))'
    foo.foo<Bar, bool, int>(&bar, &Bar::bar);
                                           ^
test.cpp:24:10: note: candidate: template<class T, class Out, class ... In> void Foo::foo(T*, void (T::*)(In ..., Out*))
    void foo(T *obj, void(T::*func)(In ..., Out*))
         ^
test.cpp:24:10: note    template argument deduction/substitution failed:
test.cpp:41:44: note    mismatched types 'bool*' and 'int'
    foo.foo<Bar, bool, int>(&bar, &Bar::bar);
                                           ^

The interesting things is that when I make In a simple type instead of parameter pack then it compiles and works correctly. This seems to me like if the compiler did not expand the pack somewhere and try to match the second argument ( bool* ) to the first argument ( int ) instead of the second one.

Answer 1

Not sure exactly why your example doesn't work, but a possible solution is to write a trait to check if the last type in a parameter pack is a pointer, then std::enable_if on that:

template <typename... Ts>
struct last_is_pointer : std::false_type{};

template <typename T1, typename T2, typename... Ts>
struct last_is_pointer<T1, T2, Ts...> : last_is_pointer<T2,Ts...>{};

template <typename T>
struct last_is_pointer<T> : std::is_pointer<T>{};

class Foo {
public:
    Foo() {}

    template<typename T, typename... Args>
    typename std::enable_if<last_is_pointer<Args...>::value>::type
    foo(T *obj, void(T::*func)(Args...)) {

    }
};

Then simply call this without specifying any template arguments:

foo.foo(&bar, &Bar::bar);

Live Demo

Answer 2

After a bit more of messing around with compilers, I found a simple workaround in a form of a template wrapper. Apparently gcc and clang have no problem with expanding the In ... pack before Out* in a type alias ( using or typedef ) and only struggle when it's part of a function definition.

namespace detail {
    template<typename T, typename Out, typename ... In>
    struct funcHelper {
        using type = void(T::*)(In ..., Out*);
    };
}

class Foo {
public:
    Foo() {}

    template<typename T, typename Out, typename ... In>
    void foo(T *obj, typename detail::funcHelper<T, Out, In ...>::type func) {
        ...
    }
    ...
};



class Bar {
public:
    Bar() {}
    void bar(int in, bool *out) {
        ...
    }
};

int main()
{
   Foo foo;
   Bar bar;

   foo.foo<Bar, bool, int>(&bar, &Bar::bar);
   ...
}