[This question][1] on the [object generator pattern][2] got me thinking about ways to automate it.

Essentially, I want to automate the creation of functions like `std::make_pair`, `std::bind1st` and `std::mem_fun` so that instead of having to write a different function for each template class type, you could write a single variadic template template function that handles all cases at once. Usage of this function would be like:

    make&lt;std::pair&gt;(1, 2);         // equivalent to std::make_pair(1, 2)
    make&lt;std::binder2nd&gt;(&amp;foo, 3); // equivalent to std::bind2nd(&amp;foo, 3);

Is it possible to write this function `make`? I have tried this, but it doesn&#39;t work in GCC 4.5 or 4.6:

    template &lt;template &lt;typename...&gt; class TemplateClass, typename... Args&gt;
    TemplateClass&lt;Args...&gt; make(Args&amp;&amp;... args)
    {
        return TemplateClass&lt;Args...&gt;(std::forward&lt;Args&gt;(args)...);
    }

If I try to call (e.g) `make&lt;std::pair&gt;(1, 2)` I just get

    error: no matching function for call to &#39;make(int, int)&#39;

Have I got the syntax wrong anywhere here?  
Or is this right and GCC is wrong?  
Or is this just fundamentally impossible in C++0x?

[edit]

Proposal [N2555][3] seems to suggest that this is allowed and [GCC claims to have implemented it in GCC4.4][4].


  [1]: https://stackoverflow.com/questions/6485791/c-instantiate-a-templated-class-according-to-an-argument/6485843#6485843
  [2]: http://en.wikibooks.org/wiki/More_C++_Idioms/Object_Generator
  [3]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf
  [4]: http://gcc.gnu.org/projects/cxx0x.html

Variadic template templates and perfect forwarding

The C++20 feature `std::source_location` is used to capture information about the context in which a function is called. 
When I try to use it with a variadic template function, I encountered a problem: I can&#39;t see a place to put the `source_location` parameter.

The following doesn&#39;t work because variadic parameters have to be at the end:

    // doesn&#39;t work
    template &lt;typename... Args&gt;
    void debug(Args&amp;&amp;... args,
               const std::source_location&amp; loc = std::source_location::current());

The following doesn&#39;t work either because the caller will be screwed up by the parameter inserted in between:

    // doesn&#39;t work either, because ...
    template &lt;typename... Args&gt;
    void debug(const std::source_location&amp; loc = std::source_location::current(),
               Args&amp;&amp;... args);

    // the caller will get confused
    debug(42); // error: cannot convert 42 to std::source_location

I was informed in a [comment](https://stackoverflow.com/questions/57540155/issue-converting-a-macro-with-variable-args-into-constexpr-variadic-templa#comment101546068_57540155) that `std::source_location` works seamlessly with variadic templates, but I struggle to figure out how.  How can I use `std::source_location` with variadic template functions?

How to use source_location in a variadic template function?

I would like to do

    template&lt;typename... ArgTypes&gt; void print(ArgTypes... Args)
    {
       print(Args)...;
    }

And have it be equivalent to this quite bulky recursive chain:

    template&lt;typename T, typename... ArgTypes&gt; void print(const T&amp; t, ArgTypes... Args)
    {
      print(t);
      print(Args...);
    }

followed by explicit single-parameter specializations for every type I&#39;d like to print.

The &quot;problem&quot; with the recursive implementation is that a lot of redundant code is generated, because each recursive step results in a new function of `N-1` arguments, whereas the code I&#39;d like to have would only generate code for a single `N`-arg `print` function, and have at most `N` specialized `print` functions.

How to call a function on all variadic template args?

The following paper is the first proposal I found for template parameter packs.

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1603.pdf

At page 16, it talks about introducing two new operators [] and &lt;&gt; for accessing parameter pack elements and parameter pack types. 

`The suggested syntax for such an operator involves two new operators: .[] to access values and .&lt;&gt; to access types. For instance:`

    template&lt;int N, typename Tuple&gt; struct tuple_element;
    template&lt;int N, ... Elements&gt;
    struct tuple_element&lt;tuple&lt;Elements...&gt; &gt;
    {
        typedef Elements.&lt;N&gt; type;
    };

    template&lt;int N, ... Elements&gt;
    Elements.&lt;N&gt;&amp; get(tuple&lt;Elements...&gt;&amp; t)
    { return t.[N]; }

    template&lt;int N, ... Elements&gt;
    const Elements.&lt;N&gt;&amp; get(const tuple&lt;Elements...&gt;&amp; t)
    { return t.[N]; }

So where are these operators? If there is none, what is their replacement?

template parameter packs access Nth type and Nth element

Can we restrict variadic template arguments to a certain type? I.e., achieve something like this (not real C++ of course):

    struct X {};

    auto foo(X... args)

Here my intention is to have a function which accepts a variable number of `X` parameters.

The closest we have is this:

    template &lt;class... Args&gt;
    auto foo(Args... args)

but this accepts any type of parameter.

Restrict variadic template arguments

I&#39;m trying to store in a `std::tuple` a varying number of values, which will later be used as arguments for a call to a function pointer which matches the stored types.

I&#39;ve created a simplified example showing the problem I&#39;m struggling to solve:

    #include &lt;iostream&gt;
    #include &lt;tuple&gt;
    
    void f(int a, double b, void* c) {
      std::cout &lt;&lt; a &lt;&lt; &quot;:&quot; &lt;&lt; b &lt;&lt; &quot;:&quot; &lt;&lt; c &lt;&lt; std::endl;
    }
    
    template &lt;typename ...Args&gt;
    struct save_it_for_later {
      std::tuple&lt;Args...&gt; params;
      void (*func)(Args...);
    
      void delayed_dispatch() {
    	 // How can I &quot;unpack&quot; params to call func?
    	 func(std::get&lt;0&gt;(params), std::get&lt;1&gt;(params), std::get&lt;2&gt;(params));
    	 // But I *really* don&#39;t want to write 20 versions of dispatch so I&#39;d rather 
         // write something like:
    	 func(params...); // Not legal
      }
    };
    
    int main() {
      int a=666;
      double b = -1.234;
      void *c = NULL;
      
      save_it_for_later&lt;int,double,void*&gt; saved = {
                                     std::tuple&lt;int,double,void*&gt;(a,b,c), f};
      saved.delayed_dispatch();
    }

Normally for problems involving `std::tuple` or variadic templates I&#39;d write another template like `template &lt;typename Head, typename ...Tail&gt;` to recursively evaluate all of the types one by one, but I can&#39;t see a way of doing that for dispatching a function call.

The real motivation for this is somewhat more complex and it&#39;s mostly just a learning exercise anyway. You can assume that I&#39;m handed the tuple by contract from another interface, so can&#39;t be changed but that the desire to unpack it into a function call is mine. This rules out using `std::bind` as a cheap way to sidestep the underlying problem.
 
What&#39;s a clean way of dispatching the call using the `std::tuple`, or an alternative better way of achieving the same net result of storing/forwarding some values and a function pointer until an arbitrary future point?

&quot;unpacking&quot; a tuple to call a matching function pointer

Why is there no `std::make_unique` function template in the standard C++11 library? I find

    std::unique_ptr&lt;SomeUserDefinedType&gt; p(new SomeUserDefinedType(1, 2, 3));

a bit verbose. Wouldn&#39;t the following be much nicer?

    auto p = std::make_unique&lt;SomeUserDefinedType&gt;(1, 2, 3);

This hides the `new` nicely and only mentions the type once.

Anyway, here is my attempt at an implementation of `make_unique`:

    template&lt;typename T, typename... Args&gt;
    std::unique_ptr&lt;T&gt; make_unique(Args&amp;&amp;... args)
    {
    	return std::unique_ptr&lt;T&gt;(new T(std::forward&lt;Args&gt;(args)...));
    }

It took me quite a while to get the `std::forward` stuff to compile, but I&#39;m not sure if it&#39;s correct. Is it? What exactly does `std::forward&lt;Args&gt;(args)...` mean? What does the compiler make of that?

make_unique and perfect forwarding

I was just writing a generic object factory and using the boost preprocessor meta-library to make a variadic template (using 2010 and it doesn&#39;t support them). My function uses rval references and `std::forward` to do perfect forwarding and it got me thinking...when C++0X comes out and I had a standard compiler I would do this with real variadic templates.  How though, would I call `std::forward` on the arguments?

    template &lt;typename ...Params&gt;
    void f(Params... params) // how do I say these are rvalue reference?
    {
        y(std::forward(...params)); //? - I doubt this would work.
    }

Only way I can think of would require manual unpacking of ...params and I&#39;m not quite there yet either. Is there a quicker syntax that would work?


How would one call std::forward on all arguments in a variadic function?

While browsing through gcc&#39;s current implementation of new C++11 headers, I stumbled upon &quot;......&quot; token. You can check, that the following code [compiles fine][1] [via godbolt.org].

    template &lt;typename T&gt;
    struct X
    { /* ... */ };

    template &lt;typename T, typename ... U&gt;
    struct X&lt;T(U......)&gt; // this line is the important one
    { /* ... */ };

So, what is the meaning of this token?

edit: Looks like SO trimmed &quot;......&quot; in question title to &quot;...&quot;, I did really mean &quot;......&quot; . :)

  [1]: https://godbolt.org/z/4GfbYYb75

What is the meaning of &quot;... ...&quot; token? i.e. double ellipsis operator on parameter pack

In C++11 there are variadic templates like this one:

    template&lt; class T, class... Args &gt;
    unique_ptr&lt;T&gt; make_unique( Args&amp;&amp;... args )
    {
        return unique_ptr&lt;T&gt;(new T(std::forward&lt;Args&gt;(args)...));
    }

There are some curiosities about this: The expression `std::forward&lt;Args&gt;(args)...` uses both `Args` and `args` but only one `...` token. Furthermore `std::forward` is a non-variadic template function taking only one template parameter and one argument. What are the syntax rules for that (roughly)? How can it be generalized? 

Also: In the function implementation the ellipsis (`...`) is at the end of the expression of interest. Is there a reason that in the template argument list and the parameter list the ellipsis is in the middle?

What are the rules for the &quot;...&quot; token in the context of variadic templates?

How can I get a count of the number of arguments to a variadic template function?

ie:

    template&lt;typename... T&gt;
    void f(const T&amp;... t)
    {
        int n = number_of_args(t);
  
        ...
    }

What is the best way to implement `number_of_args` in the above?


C++11: Number of Variadic Template Function Parameters?

Is it possible to store a parameter pack somehow for a later use?

    template &lt;typename... T&gt;
    class Action {
    private:        
        std::function&lt;void(T...)&gt; f;
        T... args;  // &lt;--- something like this
    public:
        Action(std::function&lt;void(T...)&gt; f, T... args) : f(f), args(args) {}
        void act(){
            f(args);  // &lt;--- such that this will be possible
        }
    }

Then later on:
    
    void main(){
        Action&lt;int,int&gt; add([](int x, int y){std::cout &lt;&lt; (x+y);}, 3, 4);

        //...

        add.act();
    }

How to store variadic template arguments?

This is a follow-up to my previous question on [pretty-printing STL containers](https://stackoverflow.com/questions/4850473/pretty-print-c-stl-containers), for which we managed to develop a very elegant and fully general solution.

---

In this next step, I would like to include pretty-printing for `std::tuple&lt;Args...&gt;`, using variadic templates (so this is strictly C++11). For `std::pair&lt;S,T&gt;`, I simply say

    std::ostream &amp; operator&lt;&lt;(std::ostream &amp; o, const std::pair&lt;S,T&gt; &amp; p)
    {
      return o &lt;&lt; &quot;(&quot; &lt;&lt; p.first &lt;&lt; &quot;, &quot; &lt;&lt; p.second &lt;&lt; &quot;)&quot;;
    }

What is the analogous construction for printing a tuple?

I&#39;ve tried various bits of template argument stack unpacking, passing indices around and using SFINAE to discover when I&#39;m at the last element, but with no success. I shan&#39;t burden you with my broken code; the problem description is hopefully straight-forward enough. Essentially, I&#39;d like the following behaviour:

    auto a = std::make_tuple(5, &quot;Hello&quot;, -0.1);
    std::cout &lt;&lt; a &lt;&lt; std::endl; // prints: (5, &quot;Hello&quot;, -0.1)

Bonus points for including the same level of generality (char/wchar_t, pair delimiters) as the the previous question!

Pretty-print std::tuple

I am trying to learn variadic templates and functions. I can&#39;t understand why this code doesn&#39;t compile:

    template&lt;typename T&gt;
    static void bar(T t) {}
    
    template&lt;typename... Args&gt;
    static void foo2(Args... args)
    {
    	(bar(args)...);
    }
    
    int main()
    {
		foo2(1, 2, 3, &quot;3&quot;);
		return 0;    
    }

When I compile it fails with the error:

&gt; Error C3520: &#39;args&#39;: parameter pack must be expanded in this context

(in function `foo2`).


Variadic template pack expansion

**PREMISE:**

After playing around with variadic templates a little bit, I realized that achieving anything which goes slightly beyond the trivial meta-programming tasks soon becomes pretty cumbersome. In particular, I found myself wishing for a way to perform **generic operations over an argument pack** such as *iterate*, *split*, *loop* in a `std::for_each`-like fashion, and so on.

After watching [this lecture by Andrei Alexandrescu][1] from C++ and Beyond 2012 on the desirability of `static if` into C++ (a construct borrowed from the [D Programming Language][2]) I had the feeling that some sort of `static for` would come handy as well - and I feel more of these `static` constructs could bring benefit.

So I started wondering if there is a way to achieve **something like this** for argument packs of a variadic template function (*pseudo-code*):

    template&lt;typename... Ts&gt;
    void my_function(Ts&amp;&amp;... args)
    {
        static for (int i = 0; i &lt; sizeof...(args); i++) // PSEUDO-CODE!
        {
            foo(nth_value_of&lt;i&gt;(args));
        }
    }

Which would get translated *at compile-time* into something like this:

    template&lt;typename... Ts&gt;
    void my_function(Ts&amp;&amp;... args)
    {
        foo(nth_value_of&lt;0&gt;(args));
        foo(nth_value_of&lt;1&gt;(args));
        // ...
        foo(nth_value_of&lt;sizeof...(args) - 1&gt;(args));
    }

In principle, `static_for` would allow for even more elaborate processing:

    template&lt;typename... Ts&gt;
    void foo(Ts&amp;&amp;... args)
    {
        constexpr s = sizeof...(args);

        static for (int i = 0; i &lt; s / 2; i++)
        {
            // Do something
            foo(nth_value_of&lt;i&gt;(args));
        }

        static for (int i = s / 2; i &lt; s; i++)
        {
            // Do something different
            bar(nth_value_of&lt;i&gt;(args));
        }
    }

Or for a more expressive idiom like this one:

    template&lt;typename... Ts&gt;
    void foo(Ts&amp;&amp;... args)
    {
        static for_each (auto&amp;&amp; x : args)
        {
            foo(x);
        }
    }

**RELATED WORK:**

I did some search on the Web and found out that *something* does indeed exist:

 - [This link][3] describes how to convert a parameter pack into a Boost.MPL vector, but that only goes half the way (if not less) towards the goal;
 - [this question on SO][4] seems to call for a similar and slightly related meta-programming feature (splitting an argument pack into two halves) - actually, there are several questions on SO which seem to be related to this issue, but none of the answer I have read solves it satisfactorily IMHO;
 - [Boost.Fusion][5] defines algorithms for converting an argument pack into a *tuple*, but I would prefer:
   1. not to create **unnecessary temporaries** to hold arguments that can (and should be) perfectly forwarded to some generic algorithms;
   2. have a **small, self-contained** library to do that, while Boost.Fusion is likely to include way more stuff than is needed to address this issue.

**QUESTION:**

Is there a relatively simple way, possibly through some template meta-programming, to achieve what I am looking for without incurring in the limitations of the existing approaches?


  [1]: http://channel9.msdn.com/Events/GoingNative/GoingNative-2012/Static-If-I-Had-a-Hammer%20I%20have
  [2]: http://dlang.org/index.html
  [3]: http://blog.shandyba.com/2009/12/17/converting-variadic-template-arguments-pack-to-boost-mpl-sequence/
  [4]: https://stackoverflow.com/questions/5484930/split-variadic-template-arguments
  [5]: http://www.boost.org/libs/fusion/

How to make generic computations over heterogeneous argument packs of a variadic template function?

I was experimenting with C++0x variadic templates when I stumbled upon this issue:

    template &lt; typename ...Args &gt;
    struct identities
    {
        typedef Args type; //compile error: &quot;parameter packs not expanded with &#39;...&#39;
    };

    //The following code just shows an example of potential use, but has no relation
    //with what I am actually trying to achieve.
    template &lt; typename T &gt;
    struct convert_in_tuple
    {
        typedef std::tuple&lt; typename T::type... &gt; type;
    };

    typedef convert_in_tuple&lt; identities&lt; int, float &gt; &gt;::type int_float_tuple;

GCC 4.5.0 gives me an error when I try to typedef the template parameters pack.

Basically, I would like to &quot;store&quot; the parameters pack in a typedef, without unpacking it. Is it possible? If not, is there some reason why this is not allowed?

Is it possible to &quot;store&quot; a template parameter pack without expanding it?

Function *one()* accepts one parameter pack. Function *two()* accepts two. Each pack is constrained to be wrapped in types *A* and *B*. Why is it impossible to instantiate *two()*?

    template &lt;typename T&gt;
    struct A {};
    
    template &lt;typename T&gt;
    struct B {};
    
    template &lt;typename... Ts&gt;
    void one(A&lt;Ts&gt; ...as) {
    }
    
    template &lt;typename... Ts, typename... Us&gt;
    void two(A&lt;Ts&gt; ...as, B&lt;Us&gt; ...bs) {
    }
    
    int main() {
      auto a = A&lt;int&gt;();
      auto b = B&lt;int&gt;();

      // Just fine
      one();
      one(a);
      one(a, a);

      // All errors    
      two();
      two(a);
      two(a, b);
    }

Tried with gcc and clang.

    sam@wish:~/x/cpp$ gcc -std=c++0x variadic_templates.cpp 
    variadic_templates.cpp: In function ‘int main()’:
    variadic_templates.cpp:23:7: error: no matching function for call to ‘two()’
    variadic_templates.cpp:23:7: note: candidate is:
    variadic_templates.cpp:11:6: note: template&lt;class ... Ts, class ... Us&gt; void two(A&lt;Ts&gt;..., B&lt;Us&gt;...)
    variadic_templates.cpp:24:8: error: no matching function for call to ‘two(A&lt;int&gt;&amp;)’
    variadic_templates.cpp:24:8: note: candidate is:
    variadic_templates.cpp:11:6: note: template&lt;class ... Ts, class ... Us&gt; void two(A&lt;Ts&gt;..., B&lt;Us&gt;...)
    variadic_templates.cpp:25:11: error: no matching function for call to ‘two(A&lt;int&gt;&amp;, B&lt;int&gt;&amp;)’
    variadic_templates.cpp:25:11: note: candidate is:
    variadic_templates.cpp:11:6: note: template&lt;class ... Ts, class ... Us&gt; void two(A&lt;Ts&gt;..., B&lt;Us&gt;...)
    sam@wish:~/x/cpp$ clang -std=c++0x variadic_templates.cpp 
    variadic_templates.cpp:23:3: error: no matching function for call to &#39;two&#39;
      two();
      ^~~
    variadic_templates.cpp:11:6: note: candidate function template not viable: requires at least 1 argument, but 0 were provided                                                                                                                 
    void two(A&lt;Ts&gt; ...as, B&lt;Us&gt; ...bs) {}
         ^
    variadic_templates.cpp:24:3: error: no matching function for call to &#39;two&#39;                                                                                                                                                                   
      two(a);
      ^~~
    variadic_templates.cpp:11:6: note: candidate function not viable: requires 0 arguments, but 1 was provided                                                                                                                                   
    void two(A&lt;Ts&gt; ...as, B&lt;Us&gt; ...bs) {}
         ^
    variadic_templates.cpp:25:3: error: no matching function for call to &#39;two&#39;                                                                                                                                                                   
      two(a, b);
      ^~~
    variadic_templates.cpp:11:6: note: candidate function not viable: requires 0 arguments, but 2 were provided                                                                                                                                  
    void two(A&lt;Ts&gt; ...as, B&lt;Us&gt; ...bs) {}
         ^
    3 errors generated.

How can I have multiple parameter packs in a variadic template?

I&#39;m trying to find a method to iterate over an a pack variadic template argument list.
Now as with all iterations, you need some sort of method of knowing how many arguments are in the packed list, and more importantly how to individually get data from a packed argument list.

The general idea is to iterate over the list, store all data of type int into a vector&lt;int&gt;, store all data of type char* into a vector&lt;char*&gt;, and store all data of type float, into a vector&lt;float&gt;. During this process there also needs to be a seperate vector&lt;char&gt; that stores individual chars of what order the arguments went in.  As an example, when you push_back(a_float), you&#39;re also doing a push_back(&#39;f&#39;) which is simply storing an individual char to know the order of the data.  I could also use a std::string here and simply use +=.  The vector was just used as an example.

Now the way the thing is designed is the function itself is constructed using a macro, despite the evil intentions, it&#39;s required, as this is an experiment.  So it&#39;s literally impossible to use a recursive call, since the actual implementation that will house all this will be expanded at compile time; and you cannot recruse a macro.

Despite all possible attempts, I&#39;m still stuck at figuring out how to actually do this.  So instead I&#39;m using a more convoluted method that involves constructing a type, and passing that type into the varadic template, expanding it inside a vector&lt;any&gt; and then simply iterating that.  However I do not want to have to call the function like:

    foo(arg(1), arg(2.0f), arg(&quot;three&quot;);

So the real question is how can I do without such?  To give you guys a better understanding of what the code is actually doing, I&#39;ve pasted the optimistic approach that I&#39;m currently using.

    struct any {
      void do_i(int   e) { INT    = e; }
      void do_f(float e) { FLOAT  = e; }
      void do_s(char* e) { STRING = e; }
 
      int   INT;
      float FLOAT;
      char *STRING;
    };


    template&lt;typename T&gt; struct get        { T      operator()(const any&amp; t) { return T();      } };
    template&lt;&gt;           struct get&lt;int&gt;   { int    operator()(const any&amp; t) { return t.INT;    } };
    template&lt;&gt;           struct get&lt;float&gt; { float  operator()(const any&amp; t) { return t.FLOAT;  } };
    template&lt;&gt;           struct get&lt;char*&gt; { char*  operator()(const any&amp; t) { return t.STRING; } };

    #define def(name)                                  \
      template&lt;typename... T&gt;                          \
      auto name (T... argv) -&gt; any {                   \
       std::initializer_list&lt;any&gt; argin = { argv... }; \
        std::vector&lt;any&gt; args = argin;
    #define get(name,T)  get&lt;T&gt;()(args[name])
    #define end }

    any arg(int   a) { any arg; arg.INT    = a; return arg; }
    any arg(float f) { any arg; arg.FLOAT  = f; return arg; }
    any arg(char* s) { any arg; arg.STRING = s; return arg; }

I know this is nasty, however it&#39;s a pure experiment, and will not be used in production code.  It&#39;s purely an idea.  It could probably be done a better way.  But an example of how you would use this system:

    def(foo)
      int data = get(0, int);
      std::cout &lt;&lt; data &lt;&lt; std::endl;
    end

looks a lot like python. it works too, but the only problem is how you call this function.
Heres a quick example:

    foo(arg(1000));

I&#39;m required to construct a new any type, which is highly aesthetic, but thats not to say those macros are not either.  Aside the point, I just want to the option of doing:
    foo(1000);

I know it can be done, I just need some sort of iteration method, or more importantly some std::get method for packed variadic template argument lists.  Which I&#39;m sure can be done.

Also to note, I&#39;m well aware that this is not exactly type friendly, as I&#39;m only supporting int,float,char* and thats okay with me.  I&#39;m not requiring anything else, and I&#39;ll add checks to use type_traits to validate that the arguments passed are indeed the correct ones to produce a compile time error if data is incorrect.  This is purely not an issue.  I also don&#39;t need support for anything other then these POD types.

It would be highly apprecaited if I could get some constructive help, opposed to arguments about my purely illogical and stupid use of macros and POD only types.  I&#39;m well aware of how fragile and broken the code is.  This is merley an experiment, and I can later rectify issues with non-POD data, and make it more type-safe and useable.

Thanks for your undertstanding, and I&#39;m looking forward to help.
 


How can I iterate over a packed variadic template argument list?

On the [**Boost mailinglist**][1], the following clever trick to create a tuple-like entity was recently posted by @LouisDionne:

    #include &lt;iostream&gt;
    
    auto list = [](auto ...xs) { 
        return [=](auto access) { return access(xs...); }; 
    }; 
        
    auto length = [](auto xs) { 
        return xs([](auto ...z) { return sizeof...(z); }); 
    };
    
    int main()
    {
        std::cout &lt;&lt; length(list(1, &#39;2&#39;, &quot;3&quot;)); // 3    
    }

[**Live Example**][2].

The cleverness is that `list` is a lambda taking a variadic parameter-list as input, and returning a lambda as an output that will take another lambda to act on its input. Similarly, `length` is a lambda taking a list-like entity, to which it will supply the variadic `sizeof...` operator to the list&#39;s original input parameters. The `sizeof...` operator is wrapped inside a lambda so that it can be passed to the `list`.

**Question**: is there a name for this tuple-creation idiom? Perhaps from a functional programming language where higher-order functions are more commonly used.

  [1]: http://lists.boost.org/Archives/boost/2014/06/214213.php
  [2]: http://coliru.stacked-crooked.com/a/11edc69bc10817e5

All Variadic Templates Solutions on Gang of Coders

Total of 19 Variadic Templates Solutions