在模板化成员函数的返回类型中使用 std::enable_if 时的编译器差异

Question

I tried to define two "overloads" for a method in struct Node that, depending on the struct template parameter invoke different behaviours.

I am aware that I could use other methods (like if constexpr or whatever)..

My concern is that I "tricked" the gcc 9.0.0 experimental 20180919 into compiling this, but all the other recent compilers available in wandbox (permlink below) do not. I suppose gcc8 and clang6/7 do the right thing here?

Thanks for your help!

#include <iostream>
#include <type_traits>

enum laziness { lazy, nonlazy };
enum logic { AND, OR };

template<laziness LA, logic LO>
struct Node{
    template<typename = void>
    std::enable_if_t<LA==lazy> printLaziness () const {
      std::cout << "lazy" << std::endl;
    }
    template<typename = void>
    std::enable_if_t<LA==nonlazy> printLaziness () const {
      std::cout << "non-lazy" << std::endl;
    }
};


int main () {
    Node<lazy, AND> x{};
    x.printLaziness();
    Node<nonlazy, OR> y{};
    y.printLaziness();
}

https://wandbox.org/permlink/d2IaWwt9GJn31Wmq

Answer 1

The code is ill-formed, and that experimental gcc 9.0.0 is wrong to ignore it.

A key thing to understand about the SFINAE rule is that it applies when an invalid type or expression is formed while substituting a parameter of a function template into default template arguments for other function template parameters or into the function type, as described in the introduction of section [temp.deduct] ; or when determining whether a partial specialization of a class template matches or which partial specialization is most specialized. But in your code, the invalid type is formed while substituting the parameter LA of the class template, not a parameter of the function templates.

Also relevant is paragraph [temp.inst]/2 :

The implicit instantiation of a class template specialization causes

• the implicit instantiation of the declarations, but not of the definitions, of the non-deleted class member functions, member classes, scoped member enumerations, static data members, member templates, and friends; and

• the implicit instantiation of the definitions of deleted member functions, unscoped member enumerations, and member anonymous unions.

The implicit instantiation of a class template specialization does not cause the implicit instantiation of default arguments or noexcept-specifier s of the class member functions.

Since the definitions of x and y within main require the types Node<lazy, AND> and Node<nonlazy, OR> to be complete, the class template must be instantiated for these two specializations. And instantiating the class template means instantiating the function template declarations, so in each case the program is ill-formed since that declaration contains a non-dependent invalid type.

---

Side note: As you mentioned, if constexpr is probably the simplest way to solve this sort of issue in C++17. (The public function could just call one of two private functions with different names, if you desire to have the implementations separate.) But C++20 will introduce "constraints" for templates and functions which will provide an even nicer solution:

template<laziness LA, logic LO>
struct Node{
    void printLaziness () const requires (LA==lazy) {
      std::cout << "lazy" << std::endl;
    }
    void printLaziness () const requires (LA==nonlazy) {
      std::cout << "non-lazy" << std::endl;
    }
};

Unlike SFINAE tricks, it's entirely valid to have a member function constrained by an expression equivalent to false or which otherwise can never be satisfied. This means it will never be considered a viable candidate for overload resolution.