enable_if 在返回类型中没有 decltype 失败

Question

I have 3 overloads of a function each guarded by enable_if

struct thing{
    typedef int data_type;
    
    template <typename T, int N = 0, typename = typename std::enable_if<N == 0 &&  std::is_same<T, data_type>::value>::type>
    data_type data() { return 1; }
    template <typename T, int N = 0, typename = typename std::enable_if<N == 0 && !std::is_same<T, data_type>::value>::type>
    auto data() { return 0; }
    template <typename T, int N, typename = typename std::enable_if<N != 0>::type>
    auto data() { return -1; }
};

The above code fails to compile with error

test.cpp:12:10: error: ‘template<class T, int N, class> auto thing::data()’ cannot be overloaded with ‘template<class T, int N, class> auto thing::data()’
   12 |     auto data() { return -1; }
      |          ^~~~
test.cpp:10:10: note: previous declaration ‘template<class T, int N, class> auto thing::data()’
   10 |     auto data() { return 0; }

Each of these functions can be distinguished from each other with the third template argument. What is the reason behind SFINAE failure?

On the other hand the following works

template <typename T, int N = 0, typename = typename std::enable_if<N == 0 && !std::is_same<T, data_type>::value>::type>
auto data() { return 0; }
template <typename T, int N, typename = typename std::enable_if<N != 0>::type>
decltype(auto) data() { return -1; }

and returns correct results

thing t;
std::cout << "t.data<int>(): "       << t.data<int>() << std::endl;       //  1
std::cout << "t.data<double>(): "    << t.data<double>() << std::endl;    //  0
std::cout << "t.data<int, 1>(): "    << t.data<int, 1>() << std::endl;    // -1
std::cout << "t.data<double, 1>(): " << t.data<double, 1>() << std::endl; // -1

Why and how decltype helps in this situation?

Answer 1

Default (template) argument is not part of signature,

It should be

struct thing{
    typedef int data_type;
    
    template <typename T, int N = 0, typename std::enable_if<N == 0 &&  std::is_same<T, data_type>::value, int>::type = 0>
    data_type data() { return 1; }
    template <typename T, int N = 0, typename std::enable_if<N == 0 && !std::is_same<T, data_type>::value, int>::type = 0>
    auto data() { return 0; }
    template <typename T, int N, typename std::enable_if<N != 0, int>::type = 0>
    auto data() { return -1; }
};

Answer 2

Those are not overloads; they are redeclarations (and redefinitions) of the same function template:

template<class, int, class> auto data();

Default template parameters do not make a different function template; nor does a different deduced return type, however swapping auto for decltype(auto) does make a different function template.

If suitable, the best solution would be to use concepts , since a different template-constraint makes for a different function template:

template <typename T, int N = 0>
data_type data() requires (N == 0 &&  std::is_same_v<T, data_type>) { return 1; }
template <typename T, int N = 0>
auto data() requires (N == 0 && !std::is_same_v<T, data_type>) { return 0; }
template <typename T, int N>
auto data() requires (N != 0) { return -1; }

Otherwise, you could add more dummy template arguments :

template <typename T, int N = 0, typename = typename std::enable_if<N == 0 && !std::is_same<T, data_type>::value>::type>
auto data() { return 0; }
template <typename T, int N, int = 0, typename = typename std::enable_if<N != 0>::type>
auto data() { return -1; } // ^^^^^^ add dummy template parameter