What are the rules for the “…” token in the context of variadic templates?

by

In the context of variadic template, the ellipsis ... is used to unpack the template parameter pack if it appears on the right side of an expression (call this expression pattern for a moment), or it’s a pack argument if it appears on left side of the name:

...thing  // pack   : appears as template arguments
thing...  // unpack : appears when consuming the arguments

The rule is that whatever pattern is on the left side of ... is repeated — the unpacked patterns (call them expressions now) are separated by comma ,.

It can be best understood by some examples. Suppose you have this function template:

template<typename ...T> //pack
void f(T ... args)      //pack
{
   // here are unpack patterns

   g( args... );        //pattern = args
   h( x(args)... );     //pattern = x(args)
   m( y(args...) );     //pattern = args (as argument to y())
   n( z<T>(args)... );  //pattern = z<T>(args)
}

Now if I call this function passing T as {int, char, short}, then each of the function call is expanded as:

g( arg0, arg1, arg2 );           
h( x(arg0), x(arg1), x(arg2) );
m( y(arg0, arg1, arg2) );
n( z<int>(arg0), z<char>(arg1), z<short>(arg2) );

In the code you posted, std::forward follows the fourth pattern illustrated by n() function call.

Note the difference between x(args)... and y(args...) above!

You can use ... to initialize an array also as:

struct data_info
{
     boost::any  data;
     std::size_t type_size;
};

std::vector<data_info> v{{args, sizeof(T)}...}; //pattern = {args, sizeof(T)}

which is expanded to this:

std::vector<data_info> v 
{ 
   {arg0, sizeof(int)},
   {arg1, sizeof(char)},
   {arg2, sizeof(short)}
};

I just realized a pattern could even include access specifier such as public, as shown in the following example:

template<typename ... Mixins>
struct mixture : public Mixins ...  //pattern = public Mixins
{
    //code
};

In this example, the pattern is expanded as:

struct mixture__instantiated : public Mixin0, public Mixin1, .. public MixinN

That is, mixture derives publicly from all the base classes.

Hope that helps.

More Related Contents:

  1. “unpacking” a tuple to call a matching function pointer
  2. make_unique and perfect forwarding
  3. Variadic template pack expansion
  4. How to call a function on all variadic template args?
  5. How do I get the argument types of a function pointer in a variadic template class?
  6. C++11: I can go from multiple args to tuple, but can I go from tuple to multiple args? [duplicate]
  7. check variadic templates parameters for uniqueness
  8. Check at Compile-Time if Template Argument is void
  9. How to make generic computations over heterogeneous argument packs of a variadic template function?
  10. What is the meaning of “… …” token? i.e. double ellipsis operator on parameter pack
  11. Is it possible to “store” a template parameter pack without expanding it?
  12. How to create the Cartesian product of a type list?
  13. Parameter pack must be at the end of the parameter list… When and why?
  14. How to reverse the order of arguments of a variadic template function?
  15. What does this variadic template code do?
  16. Can someone please explain the “indices trick”?
  17. effective way to select last parameter of variadic template
  18. C++ parameter pack, constrained to have instances of a single type?
  19. C++11 “overloaded lambda” with variadic template and variable capture
  20. Check traits for all variadic template arguments
  21. How can I have multiple parameter packs in a variadic template?
  22. How can I expand call to variadic template base classes?
  23. C++11: Number of Variadic Template Function Parameters?
  24. How to make a variadic is_same?
  25. generic member function pointer as a template parameter
  26. how to avoid undefined execution order for the constructors when using std::make_tuple
  27. Generating one class member per variadic template argument
  28. Is there a way to write make_unique() in VS2012?
  29. How to combine std::bind(), variadic templates, and perfect forwarding?
  30. template parameter packs access Nth type and Nth element

Leave a Comment