Question

In response to .. some other question somewhere, I wrote this code.

struct no_type{};
template<typename T> struct has_apply {
    static decltype(T().apply<0u>(double())) func( T* ptr );
    static no_type func( ... );
    static const bool result = !std::is_same<no_type, decltype(func(nullptr))>::value;
};

class A {
public:
    template< unsigned n >
    void apply( const double& );

};
class B {
};

int main()
{
  std::cout << std::boolalpha << has_apply< A >::result << '\n';
  std::cout << std::boolalpha << has_apply< B >::result << '\n';
  std::cin.get();
  return( 0 );
}

Now it seems to me that result should be true if T offers a non-static member function “apply” that accepts a double rvalue and a template parameter literal, and false otherwise. However, the example given actually fails to compile for class B, when compiling has_apply<B>. Shouldn’t the fact that the substitution of T failed in the decltype statement mean that it simply calls the other func? Isn’t that kind of the point of SFINAE?

Solved in the most ridiculous, pointless fashion ever:

struct no_type{};
template<typename T> struct has_apply {
    template<typename U> static decltype(U().apply<0u>(double())) func( U* );
    template<typename U> static no_type func( ... );
    static const bool result = !std::is_same<no_type, decltype(func<T>(nullptr))>::value;
};

class A {
public:
    template< unsigned n >
    void apply( const double& );

};
class B {
};

int main()
{
  std::cout << std::boolalpha << has_apply< A >::result << '\n';
  std::cout << std::boolalpha << has_apply< B >::result << '\n';
  std::cin.get();
  return( 0 );
}

Answer 1

SFINAE applies when substitution fails for a function template’s template parameter, not for a class template’s template parameter that has the (non-template) function in question as a member, as is in your case.

After fixing that, you should at least change decltype(T().apply<0u>(double())) to decltype(T().template apply<0u>(double())) because T() expression is of a dependent type. The reason for that is this: when the compiler first sees T().apply<0u>, it doesn’t know anything about T yet, so how should it parse the tokens apply and < after .? apply might be a member template, and then < would start the argument list for it. OTOH apply might instead be a non-template member (e.g. a data member), and then < would be parsed as ‘less-than’ operator. There is an ambiguity, and it’s still too early for the compiler to resolve that at this point. There is a need for a disambiguation mechanism a programmer could use to tell the compiler what apply is expected to be: a template or not. And here comes the .template (or ->template, or ::template) construct to the rescue: if it’s present, the compiler knows it should be a template member, otherwise if it’s not present then the compiler knows the member shouldn’t be a template.

Finally here’s an example I created that works correctly and produces the desired results on g++ 4.5.0 with -std=c++0x:

#include <iostream>

template < class T >
decltype( T().template apply< 0u >( double() ) ) f( T &t )
{
    return t.template apply< 0u >( 5. );
}

const char *f( ... )
{
    return "no apply<>";
}

class A {
public:
    template < unsigned >
    int apply( double d )
    {
        return d + 10.;
    }
};

class B {};

int main()
{
    A a;
    std::cout << f( a ) << std::endl;
    B b;
    std::cout << f( b ) << std::endl;
}

Output is:

15
no apply<>

Now if you remove both .template from the first f() definition, then the output becomes:

no apply<>
no apply<>

Which is to indicate substitution failure for class A as it doesn’t have any non-template member named apply. SFINAE in action!