Passing member function templates as arguments

Yes, you can pass member function templates as arguments to other functions, but the syntax is a bit tricky. You need to use a template parameter for the class, and then a pointer-to-member syntax to pass the function.

Here's an example:

1#include <iostream>
2
3template <typename T, typename MemberFn,
4  typename... Args>
5void CallMemberFn(T& obj, MemberFn fn,
6  Args&&... args) {
7  (obj.*fn)(std::forward<Args>(args)...);
8}
9
10class Test {
11 public:
12  template <typename T>
13  void MemberFnTemplate(T x) {
14    std::cout << "In MemberFnTemplate "
15      << x << std::endl;
16  }
17};
18
19int main() {
20  Test t;
21  CallMemberFn(t,
22    &Test::template MemberFnTemplate<int>, 42);
23}

1In MemberFnTemplate 42

In CallMemberFn, T is the class type, MemberFn is a pointer-to-member function type, and Args... is a parameter pack representing the types of the arguments to be passed to the member function.

When calling CallMemberFn, we pass three things:

1. An instance of the Test class (t).
2. A pointer to the specific instantiation of the member function template we want (&Test::template MemberFnTemplate<int>). Note the use of the template keyword here, which is necessary when passing a member function template as a template argument.
3. The actual arguments to be passed to the member function (42 in this case).

Inside CallMemberFn, we unpack the args... parameter pack and forward each argument to the member function using std::forward.

This updated version of CallMemberFn is more flexible, as it can handle member function templates that take any number of arguments.

However, it's worth noting that passing member function templates as arguments is still a complex operation with tricky syntax. In many cases, you might find it simpler and more readable to use regular function templates or lambda expressions instead of member function templates if you need to pass them as arguments to other functions.