21

I am looking for something like that:

template< typename T>  
void func(T t)
{
}

template< typename... Parms> 
void anyFunc( Parms... p)
{
    func<Parms>(p)... ;  //error 
    func(p)... ;         //error 
}

If the parameter pack expansion is done inside another function call it works:

template< typename T>
int some(T t)
{}

template< typename... Parms>
void func(Parms ...p)
{}

template< typename... Parms>
void somemore(Parms... p)
{
   func( some(p)...);
}

int main() 
{
 somemore(1,2,3,4,10,8,7, "Hallo");
}

The parameter pack expansion will also work for a list of base class initializers.

Is there any solution which will also work for functions which will return 'void'. The above workaround will not, while using the function calls returning void inside a parameter list could never work.

Any ideas?

Dolanor
  • 822
  • 9
  • 19
Klaus
  • 24,205
  • 7
  • 58
  • 113
  • Hacky solution would be to combine the function call with comma operator (so the pack expansion pattern doesn't yield `void`) and use some kind of dummy function that just "eats" its arguments. Something like [this](http://ideone.com/fFyPT). Doubt it's the thing you wanted, though. :) – Vitus Aug 04 '11 at 15:12

2 Answers2

10

Unfortunately, as you noticed, expanding a parameter pack is only valid in certain contexts where the parser expects a comma-separated list of entries – contexts where the comma is just a syntactic separator, not the comma operator. This is arguably a deficiency in the current text.

An ugly workaround:

func((some(p), 0)...);

Do note that the evaluation order of function arguments, and thus the order of the some invocations, is unspecified, so you have to be careful with any side effects.

Baum mit Augen
  • 49,044
  • 25
  • 144
  • 182
JohannesD
  • 13,802
  • 1
  • 38
  • 30
  • It is easy to get the functions evaluated in the correct order by using the pack expansion in a initializer list. Attention: g++ 4.8.1 has a bug and evaluates backwards! – Klaus Sep 07 '13 at 08:17
  • 2
    What is the purpose of `, 0`? – ABu May 25 '14 at 21:19
  • 4
    @Peregring-lk: to make the expression under ellipsis `(some(p), 0)` have a non-void type—this is required, because you need a valid non-void type to pass into the helper function `func`. – liori Aug 30 '14 at 20:26
6

How about a small helper class:

template <typename Func, typename A, typename ...Args> struct Caller
{
  static void call(Func & f, A && a, Args && ...args)
  {
    f(std::forward<A>(a));
    Caller<Func, Args...>::call(f, std::forward<Args>(args)...);
  }
};

template <typename Func, typename A> struct Caller<Func, A>
{
  static void call(Func & f, A && a)
  {
    f(std::forward<A>(a));
  }
};

template <typename Func, typename ...Args>
void Call(Func & f, Args && ...args)
{
  Caller<Func, Args...>::call(f, std::forward<Args>(args)...);
}

Then you can put the following in your client code:

void foo(A);
Call(foo, a1, a2, a3);
yuyoyuppe
  • 1,582
  • 2
  • 20
  • 33
Kerrek SB
  • 464,522
  • 92
  • 875
  • 1,084