What pattern matching (if any) is applied for C++ variadic template function invocation?

Question

I just naïvely wrote this:

#include <stdio.h>

template< class... Args >
auto format_for( Args... args, int last_arg )
    -> char const*
{
    // using Specifier = char const [3];
    // static Specifier const s[] = { {'%', 'f'+(0*args), ' '}..., {'%', 'f', 0} };
    return reinterpret_cast<char const*>( "" );
}

auto main() -> int
{
    printf( "'%s'\n", format_for( 5, 2, 1 ) );
}

It crashes Visual C++ 2015 update 1, an ICE (Internal Compiler Error), and g++ 5.1.0 maintains that the function only takes one argument, presumably as a result of ignoring the Args after failing to match this template parameter:

C:\my\forums\so\081> cl printf.cpp /Feb
printf.cpp
printf.cpp(14): fatal error C1001: An internal error has occurred in the compiler.
(compiler file 'f:\dd\vctools\compiler\cxxfe\sl\p1\cxx\dymto.c', line 6771)
 To work around this problem, try simplifying or changing the program near the locations listed above.
Please choose the Technical Support command on the Visual C++
 Help menu, or open the Technical Support help file for more information

C:\my\forums\so\081> g++ printf.cpp
printf.cpp: In function 'int main()':
printf.cpp:14:43: error: no matching function for call to 'format_for(int, int, int)'
     printf( "'%s'\n", format_for( 5, 2, 1 ) );
                                           ^
printf.cpp:4:6: note: candidate: template<class ... Args> const char* format_for(Args ..., int)
 auto format_for( Args... args, int last_arg )
      ^
printf.cpp:4:6: note:   template argument deduction/substitution failed:
printf.cpp:14:43: note:   candidate expects 1 argument, 3 provided
     printf( "'%s'\n", format_for( 5, 2, 1 ) );
                                           ^

C:\my\forums\so\081> _

So,

Why does the above not compile with g++?
How can the intent (hopefully evident from the code) be expressed?
More generally, what are the rules for matching a call to declaration of variadic template function?

let alone everything, what's that line -> `{ {'%', 'f'+(0*args), ' '}..., {'%', 'f', 0} };` 0o — Angelus Mortis, Jan 28 '16 at 18:25
@AngelusMortis: It's an array initializer. With variadic argument expansion. — Cheers and hth. - Alf, Jan 28 '16 at 18:26
A parameter pack that is not the last function parameter is a non-deduced context. Is your intent for `args` to swallow everything but the last argument (which will be `last_arg`)? — Praetorian, Jan 28 '16 at 18:28
Dupe? http://stackoverflow.com/q/14768951/241631 (Yakk's answer contains the solution you're looking for) — Praetorian, Jan 28 '16 at 18:28
@Praetorian: Not sure. Basically yes a dupe, **but** I'm also very interested in how to do this correctly. That includes *expanding* the args without the last one. — Cheers and hth. - Alf, Jan 28 '16 at 18:31
Is there any super-special thing you need to do with the last one, or is it just the `' '` vs `'\0'` difference? — T.C., Jan 28 '16 at 18:39
@T.C.: Just that difference,yes. At least in this concrete case. Let's not generalize needlessly. :) — Cheers and hth. - Alf, Jan 28 '16 at 18:40
Oh, transform to index sequence, probably. I'm as dumb as usual. Hrmf. — Cheers and hth. - Alf, Jan 28 '16 at 18:42
Just realized that the args will all be of the same type, so the order doesn't matter for generating specifiers. — Cheers and hth. - Alf, Jan 28 '16 at 18:55

Columbo · Answer 1 · 2016-02-05T16:04:42.040

Args appears in a non-deduced context. In this case, that makes it being deduced as the the empty pack.

If you want to extract the last argument but maintain usual deduction rules, you can write a simple helper:

template <typename U>
constexpr U&& last(U&& u) {return std::forward<U>(u);}
template <typename U, typename... T>
constexpr decltype(auto) last(U&&, T&&... t) {return last(std::forward<T>(t)...);}

Demo.

More generally, what are the rules for matching a call to declaration of variadic template function?

Those are pretty verbose, but function parameter packs that are not trailing will generally either be deduced to empty ones or yield a deduction failure.

In your particular case, try index_sequences:

template <class... Args, std::size_t... indices>
auto format_for( std::index_sequence<indices...>, Args... args )
{
    auto tup = std::forward_as_tuple(std::forward<Args>(args)...);
    using Specifier = char const [3];
    static Specifier const s[] = { {'%', (char)('f'+(0*std::get<indices>(tup))), ' '}..., {'%', 'f', 0} };
    int last_arg = std::get<sizeof...(Args)-1>(tup);
    return s;
}

template <class... Args>
auto format_for( Args&&... args ) {
    return format_for(std::make_index_sequence<sizeof...(Args)-1>{}, 
                      std::forward<Args>(args)...);
}

…and hope that the compiler optimizes well - Demo 2. Or go down the cheeky road:

template <class... Args, std::size_t... indices>
auto format_for( std::index_sequence<indices...>, Args... args )
{
    using Specifier = char const [3];
    static Specifier const s[] = {
      {'%', (char)(indices == sizeof...(Args)-1?
       'f' : 'f'+(0*args)), ' '}... };
    int last_arg = last(args...); // As before
    return s;
}

template <class... Args>
auto format_for( Args&&... args ) {
    return format_for(std::make_index_sequence<sizeof...(Args)>{}, 
                      std::forward<Args>(args)...);
}

Demo 3.

Thanks, very nice. But I'm not so much interested in the type of the last arg. I'm interested in using the n-1 first args to generate n-1 format specifiers in a raw string constant. Is that possible? — Cheers and hth. - Alf, Jan 28 '16 at 18:36
@Cheersandhth.-Alf So you want to be able to use both the first n-1 elements as one sole pack and the last element on its own? — Columbo, Jan 28 '16 at 18:37
@Cheersandhth.-Alf Hmm, your sample code is both weird and ugly :D. Anyway, I added some approaches. — Columbo, Jan 28 '16 at 18:51

What pattern matching (if any) is applied for C++ variadic template function invocation?

1 Answers1