Another approach, which is slightly more generic than Ben’s, is as follows: #include <tuple> template <typename… Args> struct variadic_typedef { // this single type represents a collection of types, // as the template arguments it took to define it }; template <typename… Args> struct convert_in_tuple { // base case, nothing special, // just use the … Read more
Since I was not happy with what I found, I tried to work out a solution myself and ended up writing a small library which allows formulating generic operations on argument packs. My solution has the following features: Allows iterating over all or some elements of an argument pack, possibly specified by computing their indices … Read more
Here is another way to have several parameters packs using template template parameters: #include <iostream> template <typename… Types> struct foo {}; template < typename… Types1, template <typename…> class T , typename… Types2, template <typename…> class V , typename U > void bar(const T<Types1…>&, const V<Types2…>&, const U& u) { std::cout << sizeof…(Types1) << std::endl; std::cout … Read more
One of the places where a pack expansion can occur is inside a braced-init-list. You can take advantage of this by putting the expansion inside the initializer list of a dummy array: template<typename… Args> static void foo2(Args &&… args) { int dummy[] = { 0, ( (void) bar(std::forward<Args>(args)), 0) … }; } To explain the … Read more
To accomplish what you want done here, you’ll have to store your template arguments in a tuple: std::tuple<Ts…> args; Furthermore, you’ll have to change up your constructor a bit. In particular, initializing args with an std::make_tuple and also allowing universal references in your parameter list: template <typename F, typename… Args> Action(F&& func, Args&&… args) : … Read more
Yay, indices~ namespace aux{ template<std::size_t…> struct seq{}; template<std::size_t N, std::size_t… Is> struct gen_seq : gen_seq<N-1, N-1, Is…>{}; template<std::size_t… Is> struct gen_seq<0, Is…> : seq<Is…>{}; template<class Ch, class Tr, class Tuple, std::size_t… Is> void print_tuple(std::basic_ostream<Ch,Tr>& os, Tuple const& t, seq<Is…>){ using swallow = int[]; (void)swallow{0, (void(os << (Is == 0? “” : “, “) << std::get<Is>(t)), … Read more
Just write this: const std::size_t n = sizeof…(T); //you may use `constexpr` instead of `const` Note that n is a constant expression (i.e known at compile-time), which means you may use it where constant expression is needed, such as: std::array<int, n> a; //array of n elements std::array<int, 2*n> b; //array of (2*n) elements auto middle … Read more
In the context of variadic template, the ellipsis … is used to either pack or unpack parameters/arguments in a template definition, depending on the relative position where it appears: it unpacks 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 … Read more
Every instance of that oddity is paired with a case of a regular single ellipsis. template<typename _Res, typename… _ArgTypes> struct _Weak_result_type_impl<_Res(_ArgTypes…)> { typedef _Res result_type; }; template<typename _Res, typename… _ArgTypes> struct _Weak_result_type_impl<_Res(_ArgTypes……)> { typedef _Res result_type; }; template<typename _Res, typename… _ArgTypes> struct _Weak_result_type_impl<_Res(_ArgTypes…) const> { typedef _Res result_type; }; template<typename _Res, typename… _ArgTypes> struct _Weak_result_type_impl<_Res(_ArgTypes……) … Read more
You would do: template <typename …Params> void f(Params&&… params) { y(std::forward<Params>(params)…); } The … pretty much says “take what’s on the left, and for each template parameter, unpack it accordingly.”