Partial specialization for variadic template needs first non-variadic template parameter

Question

The following code

#include <iostream>
#include <utility>

template<typename F, typename... T>
struct Wrapper{ };

template<typename T>
struct is_wrapper : std::false_type {};

template<typename... T>
struct is_wrapper<Wrapper<T...>> : std::true_type {};

//template<typename F, typename... T>
//struct is_wrapper<Wrapper<F, T...>> : std::true_type {};

int main()
{
    Wrapper<int, double> w;

    std::cout << is_wrapper<decltype(w)>::value << std::endl;
}

prints 0. However, if one uncomments the two lines in the middle it prints 1.

Why doesn't it always print 1? Shouldn't the second partial specialization also cover the case which is apparently only covered by the third (commented) partial specialization?

score 1 · Accepted Answer · answered Aug 10 '15 at 12:23

The code should indeed match the partial specialization; The standard never actually disallowed this, but compilers did take a while to implement variadic templates and their deduction properly. GCC conforms since 4.9.0 and Clang as of 3.6. The relevant bug report for Clang is #22191 (I cannot find GCC's, though).

Manu343726 · Answer 2 · 2013-08-11T15:12:29.827

Normally when I write templates that would be specialized, I use a forward declaration first, and declare the cases belong as specializations. In your case, I understand that you are trying to write a variadic template without the empty-case (That is, a variadic template wich could have at least one type).

Your code surprised me because I think that you are correct, the full variadic specialization of your trait matches the hole cases... First I tried to use a forward declaration of your trait class, and define ONLY the full-variadic specialization (So if the param of the trait is not a Wrapper instance the compilation fails). And thats exactly what has ocurred, disappointing me again:

#include <iostream>
#include <utility>

template<typename F , typename... T>
struct Wrapper {};

template<typename T>
struct is_wrapper;

//template<typename T>
//struct is_wrapper : std::false_type {};

template<typename... T>
struct is_wrapper<Wrapper<T...>> : std::true_type {};

//template<typename F, typename... T>
//struct is_wrapper<Wrapper<F, T...>> : std::true_type {};

using my_wrapper_type = Wrapper<int,double>;

int main()
{   
    std::cout << std::boolalpha  << is_wrapper<my_wrapper_type>::value << std::endl;
}//"Invalid use of incomplete type" ^^^^^^^^^^^^^^^^^^^^^^^^^^^

Finally I tried with the forward declaration method in the Wrapper class. And surprisingly, it works:

#include <iostream>
#include <utility>

template<typename... T>
struct Wrapper;

template<typename F, typename... T>
struct Wrapper<F,T...>{ };


template<typename T>
struct is_wrapper : std::false_type {};

template<typename... T>
struct is_wrapper<Wrapper<T...>> : std::true_type {};

//template<typename F, typename... T>
//struct is_wrapper<Wrapper<F, T...>> : std::true_type {};


using my_wrapper_type = Wrapper<int,double>;

int main()
{
    std::cout << std::boolalpha  << is_wrapper<my_wrapper_type>::value << std::endl;
}

This prints:

true

Here is the code running at ideone.

Sincerely, I don't understand why your code fails and mine works. Its a compiler bug, or there is something what we are missing? I don't know.

The difference is the number of template parameters for the class template `Wrapper`. Your (second) version has only one template parameter, whereas the OP's version has two parameters. Your partial specialization `struct Wrapper` does not change that. — dyp, Aug 11 '13 at 15:58
@DyP OK, but if you have a template with two parameters (One normal template parameter, and a variadic template parameter) and you pass a variadic pack to this template, the variadic pack does not have to expand matching the first normal parameter, and the second parameter (The variadic parameter)? This is what I don't understand, why the pack is not expanded in that way. — Manu343726, Aug 11 '13 at 16:05
I'm still trying to figure out where (and why) the Standard forbids partial specialization to match the parameter pack in this case. Guess it's somewhere around [temp.deduct.type]/9. (Pack expansion is different from deducing.) — dyp, Aug 11 '13 at 16:14
@DyP Me too :) This is what I mean with *"I don't understand why your code fails and mine works"* — Manu343726, Aug 11 '13 at 16:19

score 0 · Answer 3 · answered May 31 '14 at 08:09

0

If I understand well your problem it's just a specialization priority,

is_wrapper<decltype(w)>

Can be specialized by 2 template :

template<typename T> // exact specialization
template<typename... T> // variadic specialization with one parameter

In this case compiler choose in priority the exact specialization and so template is never instatiate in you case.

answered May 31 '14 at 08:09

zadigus

23
5

That is incorrect. Partial specializations are always preferred to primary templates (and must be more specialized, anyway), see §14.5.5.1. – Columbo Aug 10 '15 at 12:24

Partial specialization for variadic template needs first non-variadic template parameter

3 Answers3