Yes, it’s as simple as template<int N, typename… Ts> constexpr bool number_of_args_divisible_by(Ts&&…) { return sizeof…(Ts) % N == 0; } Alternatively, you can return a more metaprogramming-friendly type: template<int N, typename… Ts> constexpr integral_constant<bool, sizeof…(Ts) % N == 0> number_of_args_divisible_by(Ts&&…) { return {}; }
There’s actually a very elegant way to end the recursion: template <typename Last> std::string type_name () { return std::string(typeid(Last).name()); } template <typename First, typename Second, typename …Rest> std::string type_name () { return std::string(typeid(First).name()) + ” ” + type_name<Second, Rest…>(); } I initially tried template <typename Last> and template <typename First, typename …Rest> but that was … Read more
This compiles in GCC 4.8 but fails in GCC 4.9, which is evidence that it’s related to CWG 1430 and bug report #59498. The fix proposed by Roy Chrihfield is the exact same one as yours: Rewriting the code to use a struct succeeds: template <typename T, typename …> struct alias { using type = … Read more
Yes it is possible. First of all you need to decide if you want to accept only the type, or if you want to accept a implicitly convertible type. I use std::is_convertible in the examples because it better mimics the behavior of non-templated parameters, e.g. a long long parameter will accept an int argument. If … Read more
Perfect capture in C++20 template <typename … Args> auto f(Args&& … args){ return [… args = std::forward<Args>(args)]{ // use args }; } C++17 and C++14 workaround In C++17 we can use a workaround with tuples: template <typename … Args> auto f(Args&& … args){ return [args = std::make_tuple(std::forward<Args>(args) …)]()mutable{ return std::apply([](auto&& … args){ // use args … Read more
Others have already answered that it can be done via std::tuple. If you want to access the Nth type of a parameter pack, you may find the following metafunction handy: template<int N, typename… Ts> using NthTypeOf = typename std::tuple_element<N, std::tuple<Ts…>>::type; Usage: using ThirdType = NthTypeOf<2, Ts…>;
That’s exactly right. I would expect it to work. So I think that GCC is in error with rejecting that. FWIW: #include <utility> template <template <typename…> class TemplateClass, typename… Args> TemplateClass<Args…> make(Args&&… args) { return TemplateClass<Args…>(std::forward<Args>(args)…); } int main() { make<std::pair>(1, 2); } // [js@HOST2 cpp]$ clang++ -std=c++0x main1.cpp // [js@HOST2 cpp]$
C++17 fold expression (f(args), …); If you call something that might return an object with overloaded comma operator use: ((void)f(args), …); Pre-C++17 solution The typical approach here is to use a dumb list-initializer and do the expansion inside it: { print(Args)… } Order of evaluation is guaranteed left-to-right in curly initialisers. But print returns void … Read more
The first form can be made to work, by adding a deduction guide: template <typename… Ts> struct debug { debug(Ts&&… ts, const std::source_location& loc = std::source_location::current()); }; template <typename… Ts> debug(Ts&&…) -> debug<Ts…>; Test: int main() { debug(5, ‘A’, 3.14f, “foo”); } DEMO
If your inputs are all of the same type, see OMGtechy‘s great answer. For mixed-types we can use fold expressions (introduced in c++17) with a callable (in this case, a lambda): #include <iostream> template <class … Ts> void Foo (Ts && … inputs) { int i = 0; ([&] { // Do things in your … Read more