variadic-templates

Trying to get more familiar with C++17, I've just noticed std::visit : template <class Visitor, class... Variants> constexpr /*something*/ visit(Visitor&& vis, Variants&&... vars); Why does std::visit not take a single variant, but rather any number of variants? I mean, you can always take some standard library function and have it take multiple parameters with the same role, working on all of them (e.g. std::find() for multiple elements in a container); or you could be taking multiple visitors and using them on the same variant. So, why this specific 'variadification'? To make multiple

Does anyone know if the following implicit capture of 'ts' is well-formed: template<class ... Ts> void bar(Ts ... ts) { } template<class ... Ts> int foo(Ts ... ts) { auto L = [=] () { bar(ts...); }; L(); return 0; } int g = foo(1, 2, 3); Does the standard clearly state anywhere that this should not be well formed? 14.5.3/6: The instantiation of a pack expansion that is not a sizeof... expression produces a list E1, E2, ..., EN , where N is the number of elements in the pack expansion parameters. Each Ei is generated by instantiating the pattern and replacing each pack expansion parameter with

I've written a working code for computing P(N,R) for packs when the pack has all different types, e.g. PermutationN<2, P<int, char, bool>> is to be P< P<int, char>, P<int, bool>, P<char, int>, P<char, bool>, P<bool, int>, P<bool, char> > But when there are repeat elements, I'm getting the wrong results. For example, PermutationN<2, P<int, int, char>> should be P< P<int, int>, P<int, char>, P<char, int> > Here is my working code for when all the types are different. I'm stuck on how to adapt it so that it gives correct results when there are repeated types in the pack. Any help would be

Abstract: Imagine a problem of the following form: One has to invoke multiple specific member functions with the same parameters on a list of functors. That makes a good problem to solve with an interface (runtime_interface, in other words a requirement of functions that those functors have to implement). The Problem I would like to discuss is the case where the list of functors is known at compile time, but might be subject to change during the further development process. Because in this case if implemented like that one is paying the runtime overhead even though all the functions to be

I am trying to write a function to determine the average of an arbitrary number of arguments, all of which have the same type. For learning purposes I am trying to do this using a variadic-templated function. This is what I have so far: template<typename T, class ... Args> T Mean(Args ... args) { int numArgs = sizeof...(args); if (numArgs == 0) return T(); // If there are no arguments, just return the default value of that type T total; for (auto value : args...) { total += value; } return total / numArgs; // Simple arithmetic average (sum divided by total) } When I try to compile this (using