SFINAE template specialization not working - c++

Question

#include <iostream>
#include <utility>
using namespace std;
template <size_t N, typename V = int> // works if typename V = void
struct T
{
const static int size = 0;
};
template <size_t N>
struct T<N,typename std::enable_if<(N>10)>::type>
{
const static int size = 1;
};
int main (){
cout << T<9>::size << endl; // 0
cout << T<19>::size << endl;// 0 WHY?
cout << T<10>::size << endl; //0
}
Not sure why the output is the way it is, why isn't the specialization getting picked up?

Answer 1

Right now, the second argument is always int, since it's the default value:
int main (){
cout << T<9, int>::size << endl;
cout << T<19, int>::size << endl;
cout << T<10, int>::size << endl;
}
But the expression typename std::enable_if<(N>10)>::type won't ever yield an int, so your specialization won't be picked. The default type for std::enable_if::type is void.
It will work only if you're sending void in the second argument (of course you don't want that):
int main (){
cout << T<9, void>::size << endl;
cout << T<19, void>::size << endl;
cout << T<10, void>::size << endl;
}
To make it work like you want, you must either make the default argument to be void, or make your constraint to always yield an int type.
template <size_t N, typename V = void>
struct T
{
const static int size = 0;
};
Or alternatively make your constrain yeild the type of your default argument:
typename std::enable_if<(N>10), int>::type
In fact, you could put any type and it wouldn't change a thing. As long as the two type matches:
// silly but works, the two types are the same.
template<size_t N, typename = decltype(std::cout)>
struct T { /* ... */ };
template <size_t N>
struct T<N, typename std::enable_if<(N>10), decltype(std::cout)>::type> { /* ... */ };

Answer 2

Due to the template parameter with default argument in your primary template, when you write T<19>::size, what you're really writing is T<19, int>::size.
Now, there exist partial specializations for your template, thus, when figuring out which specialization a simple-template-id like T<19> refers to, the compiler will try to find a matching partial specialization. To do so, it will look for a match between the actual template arguments 19, int and the template arguments given in your partial specialization
template <size_t N>
struct T<N, typename std::enable_if<(N>10)>::type>
{ // ^-------------- this here -------------^
…
};
The first step is to figure out the arguments for the parameters of your partial specialization itself. In your case, the partial specialization has one parameter template <size_t N>. This parameter is deduced by comparing the parameterized type T<N, typename std::enable_if<(N>10)>::type> to the actual type T<19, int>. Deduction yields 19 as argument for parameter N. Substituting back into the specialization, we get
struct T<N, void>
as the deduced argument list for our specialization because std::enable_if<true>::type is void. The argument list 19, void is not the same as 19, int, therefore, the specialization is not a match and the primary template will be used.
So to make this work, you have to make sure that the type produced by your std::enable_if argument matches the default argument of the last parameter of the primary template, i.e., either change the default argument to be void
template <size_t N, typename = void>
struct T
{
…
};
or make your std::enable_if produce int in the cases where you want the specialization to be used
template <size_t N>
struct T<N, std::enable_if_t<(N>10), int>>
{
…
};