How can I deduce template parameters at the end of the list in c++?

Question

I'm trying write a function that is templated on three things:

1. First type.
2. Second type.
3. Function with arguments First and Second type.

The code looks like this:

#include <iostream>
#include <typeinfo>
using namespace std;

// Assume that this function is in a library.  Can't be modified.
void bar(int x, int y) {
  cout << x << endl;
  cout << y << endl;
}

// My code is below:
template <typename Type1, typename Type2, void (*fn)(Type1, Type2)>
void foo(Type1 x1, Type2 x2) {
  fn(x1,x2);
}

int main() {
  foo<int, int, &bar>(1,2);
}

The code works but I'm unhappy that my template has to include <int, int, &bar>. I hoped that the compiler would figure out that bar has int, int as parameters and figure it out.

I tried listing the function first and the types second but in the declaration, Type1 wasn't recognized in the function prototype because it is defined later in the same prototype.

Is there an elegant solution?

Edit: I definitely don't want to pass a pointer to bar on the stack. I want to be templated on bar. The params should be just (1, 2).

Edit2: And by that, I mean that I want to write foo<&bar>(1,2).

Answer 1

This is my solution for not passing the function as a parameter:

void bar(int a, int b) {
  cout <<  a << " " << b << endl;
}

template <class F, F *fn>
struct Foo {

  template <class... Args>
  static decltype(auto) foo(Args &&... args) {
    return fn(std::forward<Args>(args)...);
  }
};

int main() {

  Foo<decltype(bar), bar>::foo(1, 2);

  return 0;
}

As you can see you have to write bar twice, once for it's type, once for it's value, but I think it is a small inconvenience.

Or the simple version (if you can't use c++11)

template <class F, F* fn>
struct Foo {

  template <class T1, class T2>
  static void foo(T1 t1, T2 t2) {
    fn(t1, t2);
  }
};

---

For those who don't mind passing the function obj as a parameter:

Option 1:

template <class T1, class T2>
void foo(T1 x1, T2 x2, void (*fn)(T1, T2)) {
  fn(x1, x2);
}

foo(1, 2, bar);

Option 2:

template <class T1, class T2, class F = void(*)(T1, T2)>
void foo(T1 x1, T2 x2, F fn)) {
  fn(x1, x2);
}

foo(1, 2, bar);

Option 3:

template <class T1, class T2, class F>
void foo(T1 x1, T2 x2, F fn)) {
  fn(x1, x2);
}

foo(1, 2, bar);

Option 3b (the real deal):

template <class T1, class T2, class F>
void foo(T1 &&x1, T2 &&x2, F &&fn)) {
  std::forward<F>(fn)(std::forward(x1), std::forward(x2));
}

foo(1, 2, bar);

Option 4 (the real real deal) (well.. depends on what you need)

template <class F, class... Args>
decltype(auto) foo(F &&fn, Args &&... args) {
  return std::forward<F>(fn)(std::forward<Args>(args)...);
}

Answer 2

You can even avoid having to type bar twice using a temporary struct containing the value. The structure will be optimized out by any decent compiler, and the bar will not be passed on a stack, in spite of being passed as an argument to the foo:

template <typename Fn>
struct FooT {
  Fn &fn;
  FooT(Fn fn):fn(fn){}
  operator Fn *() {return fn;}
};

template <typename Fn>
inline FooT<Fn> foo(Fn *fn) {return FooT<Fn>(fn);}


int main() {
  foo(bar)(1,2);
}

Note: conversion to Fn * allows fn to be called directly, without any need for argument forwarding. It is also possible to call it using a template operator () passing/forwarding arguments to it if desired, but this seems simpler and works. The templated implementation might be handy in case you need to perform something more before or after calling the fn. I am not forward arguments, just passing them, to keep it simple, this can be changed easily if necessary:

template <typename Fn>
struct FooT {
  Fn &fn;
  FooT(Fn fn):fn(fn){}
  template <typename Type1, typename Type2>
  void operator ()(Type1 x1, Type2 x2) {
    fn(x1,x2);
  }
};

Visual Studio 2012 generated code, Whole Program Optimization disabled, expand only inline (/Ob1):

  foo(bar)(1,2);
011E16F0  push        2  
011E16F2  push        1  
011E16F4  call        bar (011E13D0h)  
011E16F9  add         esp,8