Thank you for a quick hint! I’ve just tried your code and unless I do something wrong … I get this output: Syntax error:abc 8.81 Parsed:-a atoken Syntax error:-b btoken Syntax error:-c ctoken Syntax error:-d dtoken – G. Civardi 2 hours ago Okay, so, I couldn’t leave it alone :/ Turns out there was Undefined … Read more
Overload resolution works only for functions that exist in a common scope. This means that the second implementation fails to find the second overload because you don’t import function call operators from overload<Frest…> into overload<F0, Frest…>. However, a non-capturing lambda type defines a conversion operator to a function pointer with the same signature as the … Read more
One of the simplest possible examples is the following implementation of max which isn’t even templated on types. int maximum(int n) { return n; } template<typename… Args> int maximum(int n, Args… args) { return max(n, maximum(args…)); } Only slightly more complex is the canonical printf implementation: void printf(const char *s) { while (*s) { if … Read more
I think this is a subtle implementation of a Monad-like thing, specifically something in the same spirit of the continuation monad. Monads are a functional programming construction used to simulate state between different steps of a computation (Remember that a functional language is stateless). What a monad does is to chain different functions, creating a … Read more
This is gcc bug 80871. The issue is, we end up with this set of candidates for deduction: template <class… Types, class… Args> list<Types…> __f(Args… ); // constructor template <class… Args> list<Args…> __f(Args… ); // deduction-guide Both are valid (Types… can deduce as empty in the first case), but the call here should be ambiguous … Read more
With std::common_type, this is straightforward: template <class… Args, class = std::common_type_t<Args…>> void foo(Args &&… args) { } This will only be guaranteed to be SFINAE-friendly from C++17 onwards, though. Clang and GCC both implement it that way already.
Originally I just literally answered the question, but I wanted to expand this somewhat to provide a more thorough explanation of how what packs are expanded into what. This is how I think about things anyway. Any pack immediately followed by an ellipses is just expanded in place. So A<Ts…> is equivalent to A<T1, T2, … Read more
With C++17, the cleanest way is template<typename T> struct tag { using type = T; }; template<typename… Ts> struct select_last { // Use a fold-expression to fold the comma operator over the parameter pack. using type = typename decltype((tag<Ts>{}, …))::type; }; with O(1) instantiation depth.
The problem is: we have a std::tuple<T1, T2, …> and we have some function f that we can to call on each element, where f returns an int, and we want to store those results in an array. Let’s start with a concrete case: template <typename T> int f(T ) { return sizeof(T); } std::tuple<int, … Read more
The short answer is “it does it not very well”. It invokes f on each of the args…, and discards the return value. But it does so in a way that leads to unexpected behavior in a number of cases, needlessly. The code has no ordering guarantees, and if the return value of f for … Read more