Function template that takes a template template template parameter

Question

How to take a template pointer to a member function?

By templates, I mean that the following types are not known in advance:

• template param Tis a member pointer class
• template param Ris the return type
• variadic template param Args...- these are the parameters

Broken code to illustrate the problem:

template <???>
void pmf_tparam() {}

// this works, but it a function parameter, not a template parameter
template <class T, typename R, typename... Args>
void pmf_param(R (T::*pmf)(Args...)) {}    

struct A {
  void f(int) {}
};

int main() {
  pmf_tparam<&A::f>();  // What I'm looking for
  pmf_param(&A::f);     // This works but that not what I'm looking for
  return 0;
}

Is it possible to achieve the desired behavior in C ++ 11?

Answer 1

I do not think this designation is possible. There is a proposal P0127R1 to make this designation possible. The template will be declared something like this:

template <auto P> void pmf_tparam();
// ...
pmf_tparam<&S::member>();
pmf_tparam<&f>();

auto ++ Oulu, CD, ++ 17 . auto non-type :

template <typename T, T P> void pmf_tparam();
// ...
pmf_tparam<decltype(&S::member), &S::member>();
pmf_tparam<decltype(&f), &f>();

Answer 2

, , :

struct A {
  void bar() {
  }
};

template <typename T>
void foo() {
  // Here T is void (A::*)()
}

int main(void) {
  foo<decltype(&A::bar)>();
}

, , , , , ...

struct A {
    void bar() {
        std::cout << "Call A" << std::endl;    
    }
};

template <typename R, typename C, typename... Args>
struct composer {
    using return_type = R;
    using class_type = C;
    using args_seq = std::tuple<Args...>;
    using pf = R (C::*)(Args...);
};

template <typename C, typename C::pf M>
struct foo {
    static_assert(std::is_same<C, composer<void, A>>::value, "not fp");

    typename C::return_type call(typename C::class_type& inst) {
        return (inst.*M)();
    }

    template <typename... Args>
    typename C::return_type call(typename C::class_type& inst, Args&&... args) {
        return (inst.*M)(std::forward<Args...>(args...));
    }
};

template <class T, typename R, typename... Args>
constexpr auto compute(R (T::*pmf)(Args...)) {
    return composer<R, T, Args...>{};
}

int main() {
   foo<decltype(compute(&A::bar)), &A::bar> f;
   A a;
   f.call(a);
}

, ...

Answer 3

,

template <template T, T value>
void pmf_tparam() {}

pmf_tparam<decltype(&A::f), &A::f>();

Answer 4

, .

With optional decltype(still in the templated parameter) this works:

#include <iostream>
using namespace std;

template <typename T, T ptr>
void foo (){
    ptr();
}

void noop() {
    cout << "Hello" << endl;
}

int main() {
    //Here have to use decltype first
    foo<decltype(&noop), noop>();

    return 0;
}