Pack expansion (C++11)
A pack expansion is an expression that contains one or more parameter packs followed by an ellipsis to indicate that the parameter packs are expanded. Consider the following example:
template<class...T> void func(T...a){};
template<class...U> void func1(U...b){
func(b...);
}In this example, T... and U... are the corresponding pack expansions of the template parameter packs T and U, and b... is the pack expansion of the function parameter pack b.
A pack expansion can be used in the following contexts:
- Expression list
- Initializer list
- Base specifier list
- Member initializer list
- Template argument list
- Exception specification list
Expression list
Example:
#include <cstdio>
#include <cassert>
template<class...A> void func1(A...arg){
assert(false);
}
void func1(int a1, int a2, int a3, int a4, int a5, int a6){
printf("call with(%d,%d,%d,%d,%d,%d)\n",a1,a2,a3,a4,a5,a6);
}
template<class...A> int func(A...args){
int size = sizeof...(A);
switch(size){
case 0: func1(99,99,99,99,99,99);
break;
case 1: func1(99,99,args...,99,99,99);
break;
case 2: func1(99,99,args...,99,99);
break;
case 3: func1(args...,99,99,99);
break;
case 4: func1(99,args...,99);
break;
case 5: func1(99,args...);
break;
case 6: func1(args...);
break;
default:
func1(0,0,0,0,0,0);
}
return size;
}
int main(void){
func();
func(1);
func(1,2);
func(1,2,3);
func(1,2,3,4);
func(1,2,3,4,5);
func(1,2,3,4,5,6);
func(1,2,3,4,5,6,7);
return 0;
}The output of this example:
call with (99,99,99,99,99,99)
call with (99,99,1,99,99,99)
call with (99,99,1,2,99,99)
call with (1,2,3,99,99,99)
call with (99,1,2,3,4,99)
call with (99,1,2,3,4,5)
call with (1,2,3,4,5,6)
call with (0,0,0,0,0,0) In this example, the switch statement shows the different positions of the pack expansion args... within the expression lists of the function func1. The output shows each call of the function func1 to indicate the expansion.
Initializer list
Example:
#include <iostream>
using namespace std;
void printarray(int arg[], int length){
for(int n=0; n<length; n++){
printf("%d ",arg[n]);
}
printf("\n");
}
template<class...A> void func(A...args){
const int size = sizeof...(args) +5;
printf("size %d\n", size);
int res[sizeof...(args)+5]={99,98,args...,97,96,95};
printarray(res,size);
}
int main(void)
{
func();
func(1);
func(1,2);
func(1,2,3);
func(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20);
return 0;
}The output of this example:
size 5
99 98 97 96 95
size 6
99 98 1 97 96 95
size 7
99 98 1 2 97 96 95
size 8
99 98 1 2 3 97 96 95
size 25
99 98 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 97 96 95 In this example, the pack expansion args... is in the initializer list of the array res.
Base specifier list
Example:
#include <iostream>
using namespace std;
struct a1{};
struct a2{};
struct a3{};
struct a4{};
template<class X> struct baseC{
baseC() {printf("baseC primary ctor\n");}
};
template<> struct baseC<a1>{
baseC() {printf("baseC a1 ctor\n");}
};
template<> struct baseC<a2>{
baseC() {printf("baseC a2 ctor\n");}
};
template<> struct baseC<a3>{
baseC() {printf("baseC a3 ctor\n");}
};
template<> struct baseC<a4>{
baseC() {printf("baseC a4 ctor\n");}
};
template<class...A> struct container : public baseC<A>...{
container(){
printf("container ctor\n");
}
};
int main(void){
container<a1,a2,a3,a4> test;
return 0;
}The output of this example:
baseC a1 ctor
baseC a2 ctor
baseC a3 ctor
baseC a4 ctor
container ctorIn this example, the pack expansion baseC<A>... is in the base specifier list of the class template container. The pack expansion is expanded into four base classesbaseC<a1>, baseC<a2>, baseC<a3>, and baseC<a4>. The output shows that all the four base class templates are initialized before the instantiation of the class template container
Base specifier list
Example:
#include <iostream>
using namespace std;
struct a1{};
struct a2{};
struct a3{};
struct a4{};
template<class X> struct baseC{
baseC(int a) {printf("baseC primary ctor: %d\n", a);}
};
template<> struct baseC<a1>{
baseC(int a) {printf("baseC a1 ctor: %d\n", a);}
};
template<> struct baseC<a2>{
baseC(int a) {printf("baseC a2 ctor: %d\n", a);}
};
template<> struct baseC<a3>{
baseC(int a) {printf("baseC a3 ctor: %d\n", a);}
};
template<> struct baseC<a4>{
baseC(int a) {printf("baseC a4 ctor: %d\n", a);}
};
template<class...A> struct container : public baseC<A>...{
container(): baseC<A>(12)...{
printf("container ctor\n");
}
};
int main(void){
container<a1,a2,a3,a4> test;
return 0;
}The output of this example:
baseC a1 ctor:12
baseC a2 ctor:12
baseC a3 ctor:12
baseC a4 ctor:12
container ctorIn this example, the pack expansion baseC<A>(12)... is in the member initializer list of the class template container. The constructor initializer list is expanded to include the call for each base class baseC<a1>(12), baseC<a2>(12), baseC<a3>(12), and baseC<a4>(12).
Template argument list
Example:
#include <iostream>
using namespace std;
template<int val> struct value{
operator int(){return val;}
};
template <typename...I> struct container{
container(){
int array[sizeof...(I)]={I()...};
printf("container<");
for(int count = 0; count<sizeof...(I); count++){
if(count>0){
printf(",");
}
printf("%d", array[count]);
}
printf(">\n");
}
};
template<class A, class B, class...C> void func(A arg1, B arg2, C...arg3){
container<A,B,C...> t1; // container<99,98,3,4,5,6>
container<C...,A,B> t2; // container<3,4,5,6,99,98>
container<A,C...,B> t3; // container<99,3,4,5,6,98>
}
int main(void){
value<99> v99;
value<98> v98;
value<3> v3;
value<4> v4;
value<5> v5;
value<6> v6;
func(v99,v98,v3,v4,v5,v6);
return 0;
} The output of this example:
container<99,98,3,4,5,6>
container<3,4,5,6,99,98>
container<99,3,4,5,6,98>In this example, the pack expansion C... is expanded in the context of template argument list for the class template container.
Exception specification list
Example:
struct a1{};
struct a2{};
struct a3{};
struct a4{};
struct a5{};
struct stuff{};
template<class...X> void func(int arg) throw(X...){
a1 t1;
a2 t2;
a3 t3;
a4 t4;
a5 t5;
stuff st;
switch(arg){
case 1:
throw t1;
break;
case 2:
throw t2;
break;
case 3:
throw t3;
break;
case 4:
throw t4;
break;
case 5:
throw t5;
break;
default:
throw st;
break;
}
}
int main(void){
try{
// if the throw specification is correctly expanded, none of
// these calls should trigger an exception that is not expected
func<a1,a2,a3,a4,a5,stuff>(1);
func<a1,a2,a3,a4,a5,stuff>(2);
func<a1,a2,a3,a4,a5,stuff>(3);
func<a1,a2,a3,a4,a5,stuff>(4);
func<a1,a2,a3,a4,a5,stuff>(5);
func<a1,a2,a3,a4,a5,stuff>(99);
}
catch(...){
return 0;
}
return 1;
}In this example, the pack expansion X... is expanded in the context of exception specification list for the function template func.
If a parameter pack is declared, it must be expanded by a pack expansion. An appearance of a name of a parameter pack that is not expanded is incorrect. Consider the following example:
template<class...A> struct container;
template<class...B> struct container<B>{}In this example, the compiler issues an error message because the template parameter pack B is not expanded.
Pack expansion cannot match a parameter that is not a parameter pack. Consider the following example:
template<class X> struct container{};
template<class A, class...B>
// Error, parameter A is not a parameter pack
void func1(container<A>...args){};
template<class A, class...B>
// Error, 1 is not a parameter pack
void func2(1...){}; If more than one parameter pack is referenced in a pack expansion, each expansion must have the same number of arguments expanded from these parameter packs. Consider the following example:
struct a1{}; struct a2{}; struct a3{}; struct a4{}; struct a5{};
template<class...X> struct baseC{};
template<class...A1> struct container{};
template<class...A, class...B, class...C>
struct container<baseC<A,B,C...>...>:public baseC<A,B...,C>{};
int main(void){
container<baseC<a1,a4,a5,a5,a5>, baseC<a2,a3,a5,a5,a5>,
baseC<a3,a2,a5,a5,a5>,baseC<a4,a1,a5,a5,a5> > test;
return 0;
}In this example, the template parameter packs A, B, and C are referenced in the same pack expansion baseC<A,B,C...>.... The compiler issues an error message to indicate that the lengths of these three template parameter packs are mismatched when expanding them during the template instantiation of the class template container.