variadic template parameter pack expanding for function calls

Question

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?

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. Doubt it's the thing you wanted, though. :) — Vitus
– Vitus, Commented Aug 4, 2011 at 15:12

Baum mit Augen · Accepted Answer · 2018-11-18 20:11:14Z

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.

edited Nov 18, 2018 at 20:11

Baum mit Augen♦

50.4k25 gold badges153 silver badges187 bronze badges

answered Aug 4, 2011 at 15:16

JohannesD

14.6k1 gold badge40 silver badges30 bronze badges

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

3 Comments

Klaus Over a year ago

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!

ABu Over a year ago

What is the purpose of , 0?

liori Over a year ago

@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.

yuyoyuppe · Accepted Answer · 2019-03-30 12:30:53Z

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);

edited Mar 30, 2019 at 12:30

yuyoyuppe

1,6022 gold badges22 silver badges34 bronze badges

answered Aug 4, 2011 at 21:09

Kerrek SB

481k96 gold badges904 silver badges1.1k bronze badges

2 Comments

Kerrek SB Over a year ago

@Dolanor: Thanks for the fixes. That was a spectacular amount of mistakes for such a short post :-S

Dolanor Over a year ago

No problems. I needed to make it work to experiment, why not sharing the correction ? ;)

Collectives™ on Stack Overflow

variadic template parameter pack expanding for function calls

2 Answers 2

3 Comments

2 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

3 Comments

2 Comments

Linked

Related