“What happened to my SFINAE” redux: conditional template class members?

Question

I\'m new to writing template metaprogramming code (vs. just reading it). So I\'m running afoul of some noob issues. One of which is pretty well summarized by this non-SO p

Answer 1

The way I see it you don't want SFINAE here. SFINAE is useful to pick between different templated overloads. Basically, you use it to help the compiler pick between template void f(Pointer); and template void f(NotPointer);.

That's not what you want here. Here, you have two functions with different names, not two overloads of the same. The compiler can already pick between template void f(Pointer); and template void g(NotPointer);.

I'll give an example to explain why I think SFINAE is not only unnecessary, but undesirable here.

Foo not_pointer;
Foo pointer;

not_pointer.valid_if_pointer(); // #1
not_pointer.valid_if_not_pointer(); // #2
pointer.valid_if_pointer(); // #3
pointer.valid_if_not_pointer(); // #4

Now, let's say you managed to get this working with SFINAE. Attempting to compile this piece of code will yield errors on lines #1 and #4. Those errors will be something along the lines of "member not found" or similar. It may even list the function as a discarded candidate in overload resolution.

Now, let's say you didn't do this with SFINAE, but with static_assert instead. Like this:

template 
struct Foo {
    void valid_if_pointer(T) const {
        static_assert(std::is_pointer::value, "valid_if_pointer only works for pointers");
        // blah blah implementation
    }

    void valid_if_not_pointer(T) const {
        static_assert(!std::is_pointer::value, "valid_if_not_pointer only works for non-pointers");
        // blah blah implementation
    }
};

With this you'll get errors on the same line. But you'll get extremely short and useful errors. Something people have been asking of compiler writers for years. And it's now at your doorstep :)

You get the same thing: errors on both cases, except you get a much better one without SFINAE.

Also note that, if you didn't use static_assert at all and the implementation of the functions was only valid if given pointers or non-pointers, respectively, you would still get errors on the appropriate lines, except maybe nastier ones.

TL;DR: unless you have two actual template functions with the same name, it's preferable to use static_assert instead of SFINAE.