You could try something like this: template <typename T, typename R, typename …Args> R proxycall(T & obj, R (T::*mf)(Args…), Args &&… args) { return (obj.*mf)(std::forward<Args>(args)…); } Usage: proxycall(obj, &hello::f); Alternatively, to make the PTMF into a template argument, try specialization: template <typename T, T> struct proxy; template <typename T, typename R, typename …Args, R (T::*mf)(Args…)> … Read more
Nice and concise with C++17: template <class T, class… Ts> struct is_any : std::disjunction<std::is_same<T, Ts>…> {}; And the dual: template <class T, class… Ts> struct are_same : std::conjunction<std::is_same<T, Ts>…> {}; A variation that uses fold expressions: template <class T, class… Ts> struct is_any : std::bool_constant<(std::is_same_v<T, Ts> || …)> {}; template <class T, class… Ts> struct … 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
I see sample code around there, but I really want a dumbed down step by step explanation of how an index_sequence is coded and the meta programming principal in question for each stage. What you ask isn’t exactly trivial to explain… Well… std::index_sequence itself is very simple: is defined as follows template<std::size_t… Ints> using index_sequence … Read more
Sure. You need a context that permits pack expansion – a simple one is a braced initializer list, which also has the benefit of guaranteeing left-to-right evaluation: using expander = int[]; (void) expander { 0, ((void) As::id(), 0)… }; … expands a pattern to its left; in this case the pattern is the expression ((void) … Read more
Because when a function parameter pack is not the last parameter, then the template parameter pack cannot be deduced from it and it will be ignored by template argument deduction. So the two arguments 0, 0 are compared against , int, yielding a mismatch. Deduction rules like this need to cover many special cases (like … 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
If you want to wrap arguments to any, you can use the following setup. I also made the any class a bit more usable, although it isn’t technically an any class. #include <vector> #include <iostream> struct any { enum type {Int, Float, String}; any(int e) { m_data.INT = e; m_type = Int;} any(float e) { … Read more
Define all_true as template <bool…> struct bool_pack; template <bool… v> using all_true = std::is_same<bool_pack<true, v…>, bool_pack<v…, true>>; And rewrite your constructor to // Check convertibility to B&; also, use the fact that getA() is non-const template<typename… Args, typename = std::enable_if_t<all_true<std::is_convertible<Args&, B&>{}…>> C(Args&… args) : member{args.getA()…} {} Alternatively, under C++17, template<typename… Args, typename = std::enable_if_t<(std::is_convertible_v<Args&, B&> … Read more
Without recursive calls and commas where you wanted. In c++11 / c++14 through parameter pack expansion: template <typename Arg, typename… Args> void doPrint(std::ostream& out, Arg&& arg, Args&&… args) { out << std::forward<Arg>(arg); using expander = int[]; (void)expander{0, (void(out << ‘,’ << std::forward<Args>(args)), 0)…}; } DEMO In c++17 using fold expressions: template <typename Arg, typename… Args> … Read more