尽管使用了模板方法，但 SFINAE 不起作用

Question

考虑以下代码，它尝试使用 SFINAE 根据模板参数提供不同的方法实现。

#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;
}

这个例子的灵感来自std::enable_if的参考页面。如您所见，struct C<S> 有两个 foo 方法。如果S 是true，则应启用一个，如果S 是false，则应启用另一个。但是，代码无法编译，但会引发以下错误：

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){

因此，编译器似乎完全忽略了 SFINAE 并在发现未启用类型时引发错误。我在这里做错了什么？

Answer 1

S不是方法的模板参数，是类的模板参数。在类的实例化过程中，S 已确定，因此，std::enable_if<!S_>::type 不再依赖于类型，因此无法按照您使用它的方式使用。正如 Nawaz 回答的那样，您可以通过使用重载来解决这个问题，但您也可以将 S 设为该方法的模板参数 - 有点：

#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;
  }

这不是函数模板，因为这个（假定的）函数模板没有 模板参数。它甚至不是功能。代码格式不正确。

注意S是封闭类模板的模板参数，而不是函数（模板）。 以下代码是正确的（但不能解决您的问题）：

  template<typename SS, typename std::enable_if<!SS>::type* = nullptr>
  int foo(int i)
  {
     //etc
  }

这里typename SS定义了函数模板的模板参数。你的功能不这样做。 std::enable_if中使用的模板参数必须是相同函数模板的模板参数。

---

使用函数重载来解决你的问题：

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;
     }
};

这是一般的实现。但在这种特定情况下，当您使用 bool 作为模板参数时，另一种解决方案可能是：

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;
     }
};

由于编译器知道S，所以我相信编译器会消除return S ? foo_a(i) : foo_b(i);中的分支，而是根据S的值编写return foo_a(i);或return foo_b(i);，有效地产生更快代码。