C++ std::function-like template syntax

Question

In C++11 you can instantiate std::function like this:

std::function<void(int)> f1;
std::function<int(std::string, std::string)> f2;
//and so on

But while there is plenty of info on variadic templates on the web, I fail to find any articles on how to write std::function-like template which would accept parenthesized arguments. Could anyone please explain the syntax and its limitations or at least point to an existing explanation?

Angew is no longer proud of SO · Accepted Answer · 2014-12-22T14:16:05.757

24

There's nothing special about it, it's an ordinary function type. When you declare a function like this:

int foo(char a, double b)

Then its type is int (char, double). One way of "unwrapping" the individual argument types and return type is to use partial template specialisation. Basically, std::function looks something like this:

template <class T>
struct function; // not defined

template <class R, class... A>
struct function<R (A...)>
{
  // definition here
};

edited Dec 22 '14 at 14:16

answered Dec 22 '14 at 14:03

Angew is no longer proud of SO

167,307
17
350
455

So, if i understand correctly, int(char, double) is interpreted as a single function type, but we can then extract return type and parameter list with partial specialization? – Smiles Dec 22 '14 at 14:11
@Cynic Yes, that's exactly how it works. I've edited the answer accordingly. – Angew is no longer proud of SO Dec 22 '14 at 14:15
I need syntax like `template void foo(F(int) intCallable){...}` :/ – Mariusz Jaskółka Jan 03 '17 at 17:31
@MariuszJaskółka The syntax for that is `foo(F intCallable(int))`. It's just like any other function syntax: the name comes between the return type and the argument list. – Angew is no longer proud of SO Jan 03 '17 at 17:43

score 6 · Answer 2 · answered Dec 22 '14 at 14:05

Pretty much like any other template, since int(std::string, std::string) is just a type.

Here's a really naive example that compiles:

template <typename FType>
struct Functor
{
   Functor(FType* fptr) : fptr(fptr) {}

   template <typename ...Args>
   void call(Args... args)
   {
      fptr(args...);
   }

private:
   FType* fptr;
};

void foo(int x, char y, bool z) {}

int main()
{
   Functor<void(int, char, bool)> f(&foo);
   f.call(1, 'a', true);
   //f.call(); // error: too few arguments to function
}

In reality you'd have a specialisation on FType being ReturnType(ArgTypes...), though my naive example will already give you the validation you need if you try to invoke it in in compatible ways.

C++ std::function-like template syntax

2 Answers2