SFINAE not working although template methods are used - c++

Question

Consider the following code that tries to use SFINAE for providing different method implementations depending on a template parameter.
#include <type_traits>
#include <iostream>
template<bool S>
struct C{
template<typename std::enable_if<!S>::type* = nullptr>
int foo(int i){
return i + 1;
}
template<typename std::enable_if<S>::type* = nullptr>
int foo(int i){
return i;
}
};
int main(){
C<true> c1;
C<false> c2;
std::cout << c1.foo(0) << c2.foo(0) << std::endl;
}
This example is inspired by the reference page of std::enable_if. As you see, struct C<S> has two foo methods. One should be enabled if S is true, and the other if S is false. However, the code does not compile but raises the following errors:
src/test.cpp: In instantiation of ‘struct C<true>’:
src/test.cpp:19:12: required from here
src/test.cpp:7:8: error: no type named ‘type’ in ‘struct std::enable_if<false, void>’
int foo(int i){
^
src/test.cpp: In instantiation of ‘struct C<false>’:
src/test.cpp:20:13: required from here
src/test.cpp:12:8: error: no type named ‘type’ in ‘struct std::enable_if<false, void>’
int foo(int i){
So it seems that the compiler completelty ignores SFINAE and raises an error once it finds that a type is not enabled. What am I doing wrong here?

Answer 1

S is not a template parameter of the method, it is a template parameter of the class. During instantiation of the class, S has been determined, and as a result, std::enable_if<!S_>::type is no longer type-dependent so cannot be used the way you're using it. You can, as Nawaz answered, solve this by using overloading, but you can also make S a template parameter of the method -- sort of:
#include <type_traits>
#include <iostream>
template<bool S>
struct C {
template<bool S_ = S, typename std::enable_if<!S_>::type* = nullptr>
int foo(int i){
return i + 1;
}
template<bool S_ = S, typename std::enable_if<S_>::type* = nullptr>
int foo(int i) {
return i;
}
};
int main(){
C<true> c1;
C<false> c2;
std::cout << c1.foo(0) << c2.foo(0) << std::endl;
}

Answer 2

template<typename std::enable_if<!S>::type* = nullptr>
int foo(int i)
{
return i + 1;
}
This is NOT function template, because there is NO template parameter for this (supposedly) function template. It is not even function. The code is simply ill-formed.
Note that S is a template parameter of the enclosing class template, not the function (template).
The following code would be correct (but wouldn't solve your problem):
template<typename SS, typename std::enable_if<!SS>::type* = nullptr>
int foo(int i)
{
//etc
}
Here typename SS defines template parameter for the function template. Your function doesn't do so. The template parameter used in std::enable_if must be a template parameter of the same function template.
Use function overloading to solve your problem:
template<bool S>
struct C
{
int foo(int i)
{
return foo_impl(std::integral_constant<bool, S>(), i);
}
private:
int foo_impl(std::true_type, int i)
{
return i + 1;
}
int foo_impl(std::false_type, int i)
{
return i;
}
};
That is the general implementation. But in this specific case, when you're using bool as template parameter, then another solution could be this:
template<bool S>
struct C
{
int foo(int i)
{
return S ? foo_a(i) : foo_b(i);
}
private:
int foo_a(int i)
{
return i + 1;
}
int foo_b(int i)
{
return i;
}
};
Since S is known to the compiler, so I believe the compiler would eliminate the branching in return S ? foo_a(i) : foo_b(i); and would instead write either return foo_a(i); or return foo_b(i); based on the value of S, effectively producing faster code.