Parameter packs not expanded with '...'

Question

I have this code:

#include <iostream>
using namespace std;

int print(int i)
{
    cout << endl << i;
}

template<typename ...Args>
inline void pass(Args&&...args)
{

}

template<typename ...args>
inline void expand(args&&... a)
{
    print(a) ...; //this doesn't expand
    //pass( print(a)... ); this works
}

int main() {
    expand(1,2,3,4);
    return 0;
}

It throws an error:

 In function 'void expand(args&& ...)':
error: expected ';' before '...' token
  print(a) ...;
           ^
parameter packs not expanded with '...':
  print(a) ...;
              ^

Why is the use of the pass() function necessary?

Parameter pack expansion is allowed basically where a comma-separated list is allowed. There is a fixed number of contexts: function parameter lists, template parameter lists, initializers etc. An expression is not a valid context. A comma operator doesn't make a comma-separated list. — n. m. could be an AI, Nov 23 '15 at 10:27

score 26 · Accepted Answer · edited Nov 25 '15 at 12:32

26

Essentially, expanding a parameter pack E... produces a list E1, E2, [...], EN, one E for each element in the pack. This syntactic construct is only valid in places where lists are grammatically correct, such as in function calls, initializer lists etc. An expression containing multiple comma operators does not count.

I believe that with fold expressions (N4295: Folding expressions (Andrew Sutton, Richard Smith)) you'll be able to simply write:

(print(a), ...);

In this expression,

print(a) is an expression with an unexpanded parameter pack,
, is the operator and
... designates the right fold expansion.

The result of the entire expression is that (print(a), ...) will be transformed into

print(a1) , (print(a2), (print(a3), print(a4))) // (assuming four elements).

edited Nov 25 '15 at 12:32

Micha Wiedenmann

19,979
21
92
137

answered Nov 23 '15 at 10:28

TartanLlama

63,752
13
157
193

2

now you've made me wonder why this is the case, since `foo(), foo();` is a valid expression. – Richard Hodges Nov 23 '15 at 10:29
1

@RichardHodges it's a valid expression, but it's not a *list* according to the grammar. – TartanLlama Nov 23 '15 at 10:31
2

I understand that. What I am wondering is why pack expansion was limited to lists and not allowed for statements. – Richard Hodges Nov 23 '15 at 10:32
2

@RichardHodges honestly, I'm not sure. I think this will all be fixed when we get fold expressions. – TartanLlama Nov 23 '15 at 10:33
1

You're right. I tried it with apple clang using `-std=c++1z`. works as expected. – Richard Hodges Nov 24 '15 at 11:55

Nikos Athanasiou · Answer 2 · 2015-11-23T11:15:35.937

7

Pack expansions can only happen in pack expansion contexts. These essentially are :

braced initialization
initializer lists
aggregate initializations
function calls
array initializations

Of these the easier to use in your case would be the last :

#include <iostream>
using namespace std;
int print(int i)
{
    cout<<endl<<i;
    return 0;
}

template<typename ...args>
inline void expand(args&&... a)
{
    using expander = int[]; 
    (void)expander{0, ((void)print(a), 0)...}; 
}

int main() 
{
    expand(1,2,3,4);

    return 0;
}

Demo

edited Nov 23 '15 at 11:15

answered Nov 23 '15 at 11:04

Nikos Athanasiou

29,616
15
87
153

1

@LightnessRacesinOrbit I don't get it – Nikos Athanasiou Nov 23 '15 at 12:28
13

I'm laughing at C++. That this syntax is the "easiest" way to do this simple thing is laughable. – Lightness Races in Orbit Nov 23 '15 at 12:37

score 4 · Answer 3 · answered Aug 29 '18 at 23:18

This one works too:

#include <iostream>

void print() {}

template<typename T, typename ... Types>
void print (T firstArg, Types ... args) {
    std::cout << firstArg << "\n";
    print(args...);
}

int main() {
    print("Hello",1337,42.44,"World");
}

Demo

score 2 · Answer 4 · edited Oct 13 '21 at 14:03

2

You may want to consider the following C++ 11 code:

#include <iostream>

template<typename T, typename... Ts>
auto printf3(T value, Ts... args) {
    std::cout << value << std::endl;
    (void) std::initializer_list<T>{([&args] {
        std::cout << args << std::endl;
    }(), value)...};
}

edited Oct 13 '21 at 14:03

Michael Haephrati

3,660
1
33
56

answered Oct 13 '21 at 12:12

alonegame

49
4

score 1 · Answer 5 · answered Jan 28 '21 at 09:11

with C++17 and fold expressions, the above code could be simplified as shown below:

#include <iostream>

template<typename ...args>
inline void print(args&&... a) {
    ((std::cout << a << std::endl), ...);
}

int main() {
    print(1,2,3,4);
    return 0;
}

Parameter packs not expanded with '...'

5 Answers5

Linked