#include <iostream>

namespace detail
{

  ///////////////////////////////////////////////////////////////////////////////
  // function_ptr_baseN
  ///////////////////////////////////////////////////////////////////////////////

  template<class R, class C, R (C::*pmf)()>
  struct function_ptr_base0
  {
  public:
    typedef R (*ftype)(C *);
    operator ftype() { return f; }

  private:
    static R f(C *c) { return (c->*pmf)(); }
  };

  template<class R, class C, class A1, R (C::*pmf)(A1)>
  struct function_ptr_base1
  {
  public:
    typedef R (*ftype)(C *, A1);
    operator ftype() { return f; }

  private:
    static R f(C *c, A1 a1) { return (c->*pmf)(a1); }
  };

  template<class R, class C, class A1, class A2, R (C::*pmf)(A1, A2)>
  struct function_ptr_base2
  {
  public:
    typedef R (*ftype)(C *, A1, A2);
    operator ftype() { return f; }

  private:
    static R f(C *c, A1 a1, A2 a2) { return (c->*pmf)(a1, a2); }
  };

  ///////////////////////////////////////////////////////////////////////////////
  // function_ptr_impl
  ///////////////////////////////////////////////////////////////////////////////

  template<class T>
  struct function_ptr_impl;

  template<class R, class C>
  struct function_ptr_impl<R (C*)>
  {
    typedef R (C::*type)();

    template<type pmf>
    struct base : function_ptr_base0<R, C, pmf> {};
  };

  template<class R, class C, class A1>
  struct function_ptr_impl<R (C*, A1)>
  {
    typedef R (C::*type)(A1);

    template<type pmf>
    struct base : function_ptr_base1<R, C, A1, pmf> {};
  };

  template<class R, class C, class A1, class A2>
  struct function_ptr_impl<R (C*, A1, A2)>
  {
    typedef R (C::*type)(A1, A2);

    template<type pmf>
    struct base : function_ptr_base2<R, C, A1, A2, pmf> {};
  };

} // namespace detail

///////////////////////////////////////////////////////////////////////////////
// function_ptr
///////////////////////////////////////////////////////////////////////////////

template<class T, typename detail::function_ptr_impl<T>::type pmf>
struct function_ptr : detail::function_ptr_impl<T>::base<pmf> {};

///////////////////////////////////////////////////////////////////////////////
// Test
///////////////////////////////////////////////////////////////////////////////

class test
{
public:
  test(int v) : value(v) {}

  int f1() { return value; }
  int f2(int a) { return a+value; }
  int f3(int a) { return -a-value; }
  double f4(double a, double b) { return a+b; }

private:
  int value;
};

int main()
{
  test t(1);

  function_ptr<int (test *), &test::f1> f1;
  function_ptr<int (test *, int), &test::f2> f2;
  function_ptr<int (test *, int), &test::f3> f3;
  function_ptr<double (test *, double, double), &test::f4> f4;

  std::cout << f1(&t) << '\n'              // Prints "1"
            << f2(&t,3) << '\n'            // Prints "4"
            << f3(&t, 3) << '\n'           // Prints "-4"
            << f4(&t, 1.23, 2.34) << '\n'; // Prints "3.57"

            std::cin.ignore();
}