Template parameter - function pointer with variadic arguments

Question

I know I can do this:

template<typename T, typename Ret, typename A1, typename A2, Ret(T::*F)(A1, A2)>
class C{}

But as you can see this A1 and A2 are bit ugly. In fact I don't know the number of arguments. Sounds like a work for variadic templates. Unfortunately I can't do this:

// doesn't work - parameter pack must appear at the end of the template parameter list
template<typename T, typename Ret, typename... Args, Ret(T::*F)(Args...)>
class C{}

Nor this:

template class C;

// doesn't work - wrong syntax
template<typename T, typename F, typename Ret, typename... Args>
class Delegate2<Ret(T::*F)(Args...)>{}

Do I want too much?

Dimitrios Bouzas · Accepted Answer · 2016-04-11 14:13:31Z

7

You could do the following:

template<typename T, T> struct C;

template<typename T, typename R, typename ...Args, R (T::*F)(Args...)>
struct C<R (T::*)(Args...), F> {

  R operator()(T &obj, Args &&... args) {
    return (obj.*F)(std::forward<Args>(args)...);
  }

};

and then in your program:

struct A {
  int foo(int i) { return i; }
};

int main() {
  C<int(A::*)(int), &A::foo> c;
  A a;
  std::cout << c(a, 42) << std::endl;
}

Live Demo

answered Apr 11, 2016 at 14:13

Dimitrios Bouzas

43.1k11 gold badges103 silver badges177 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

nikitablack Over a year ago

Nice, really nice. It looks like this is what I wanted, thank you, thought I need first to understand how it works. Why do use template<typename T, T>? Why template<typename T> and specialization template<same as before> struct C<R (T::*F)(Args...)> doesn't work?

Yakk - Adam Nevraumont · Accepted Answer · 2016-04-11 14:15:55Z

4

template<class T>struct tag{using type=T;};
template<class Tag>using type=typename Tag::type;

template<class T, class Sig>
struct member_function_pointer;
template<class T, class Sig>
using member_function_pointer_t=type<member_function_pointer<T,Sig>>;

template<class T, class R, class...Args>
struct member_function_pointer<T, R(Args...)>:
  tag<R(T::*)(Args...)>
{};

then

template<class T, class Sig, member_function_pointer_t<T,Sig> mf>
class C{};

should do the trick. If you need access to Args..., you can specialize.

template<class T, class Sig, member_function_pointer_t<T,Sig> mf>
class C;
template<class T, class R, class...Args, member_function_pointer_t<T,R(Args...)> mf>
class C<T, R(Args...), mf> {
};

like that.

answered Apr 11, 2016 at 14:15

Yakk - Adam Nevraumont

280k31 gold badges367 silver badges584 bronze badges

2 Comments

nikitablack Over a year ago

Thank you. Looks good and scary. I can barely understand what's going on. Can you please bring some light on your approach? The thing that catch my eye is inheritance. I'm not against it but mixing templates and oop make things much more complicated.

Yakk - Adam Nevraumont Over a year ago

@nikitablack The inheritance is just there so I don't have to type { using type=blah; }, instead I just inherit from : tag<blah> {}. In metaprogramming, I often use template<whatever...> struct some_specialization<a,b,c>:is_really_this_solution<args>{} pattern.

Collectives™ on Stack Overflow

Template parameter - function pointer with variadic arguments

2 Answers 2

1 Comment

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related