为什么 SFINAE (enable_if) 从内部类定义而不是从外部工作

Question

过去几个小时我一直在努力解决一个非常奇怪的问题（在解决了 SFINAE 的 5-6 个其他问题后，因为我是新手）。基本上在下面的代码中，我想让f() 为所有可能的模板实例化工作，但只有在N == 2 时才有g()：

#include <type_traits>
#include <iostream>

template<typename T, int N>
class A
{
public:
    void f(void);
    void g(void);
};

template<typename T, int N>
inline void A<T, N>::f()
{
    std::cout << "f()\n";
}

template<typename T, int N, typename std::enable_if<N == 2, void>::type* = nullptr>
inline void A<T, N>::g()
{
    std::cout << "g()\n";
}

int main(int argc, char *argv[])
{
    A<float, 2> obj;
    obj.f();
    obj.g();

    return 0;
}

当我尝试编译它时，我得到一个关于有 3 个模板参数而不是两个的错误。然后，经过一些试验，我决定将g() 的定义移到A 本身的定义中，如下所示：

#include <type_traits>
#include <iostream>

template<typename T, int N>
class A
{
public:
    void f(void);

    template<typename t = T, int n = N, typename std::enable_if<N == 2, void>::type* = nullptr>
    void g()
    {
        std::cout << "g()\n";
    }
};

template<typename T, int N>
inline void A<T, N>::f()
{
    std::cout << "f()\n";
}

int main(int argc, char *argv[])
{
    A<float, 2> obj;
    obj.f();
    obj.g();

    return 0;
}

现在，神奇地一切正常。但我的问题是为什么？编译器没有看到在类定义中我试图内联一个也依赖于 3 个模板参数的成员函数吗？或者让我们颠倒一下这个问题：如果它在A 的定义中起作用，为什么它在外面不起作用？区别在哪里？不是还有3个参数，比A的模板参数需要哪个类多+1吗？

另外，为什么它只在我将第三个参数设为非类型而不是类型时才有效？请注意，我实际上创建了一个由 enable_if 返回的类型的指针，并为其分配了一个默认值 nullptr，但我看到我不能像在我在这里看到的其他 SO 论坛帖子中那样将它作为类型参数留在那里。

非常感谢，谢谢！！！

Answer 1

那是因为模板类中的模板函数有两组组模板参数，而不是一组。因此，“正确”的形式是：

template<typename T, int N>
class A
{
public:
    void f(void);

    template<typename std::enable_if<N == 2, void>::type* = nullptr>
    void g(void);
};

template<typename T, int N>                                            // Class template.
template<typename std::enable_if<N == 2, void>::type* /* = nullptr */> // Function template.
inline void A<T, N>::g()
{
    std::cout << "g()\n";
}

看到它在行动here。

[请注意，这实际上不正确，原因在此答案的底部进行了解释。如果N != 2，它会中断。]

如果您愿意，请继续阅读以获取解释。

---

还和我在一起吗？好的。让我们检查每种情况，好吗？

1. 在A之外定义A<T, N>::g()：

   template<typename T, int N>
   class A
   {
   public:
       void f(void);
       void g(void);
   };
   
   template<typename T, int N, typename std::enable_if<N == 2, void>::type* = nullptr>
   inline void A<T, N>::g()
   {
       std::cout << "g()\n";
   }
   

   在这种情况下，A<T, N>::g() 的模板声明与 A 的模板声明不匹配。因此，编译器会发出错误。而且g()本身没有模板化，所以在不改变A的定义的情况下，不能将模板拆分为类模板和函数模板。

   template<typename T, int N>
   class A
   {
   public:
       void f(void);
   
       // Here...
       template<typename std::enable_if<N == 2, void>::type* = nullptr>
       void g(void);
   };
   
   // And here.
   template<typename T, int N>                                            // Class template.
   template<typename std::enable_if<N == 2, void>::type* /* = nullptr */> // Function template.
   inline void A<T, N>::g()
   {
       std::cout << "g()\n";
   }
   

2. 在A内定义A<T, N>::g()：

   template<typename T, int N>
   class A
   {
   public:
       void f(void);
   
       template<typename t = T, int n = N, typename std::enable_if<N == 2, void>::type* = nullptr>
       void g()
       {
           std::cout << "g()\n";
       }
   };
   

   在这种情况下，由于g() 是内联定义的，因此它隐含了A 的模板参数，无需手动指定它们。所以g()其实就是：

   // ...
       template<typename T, int N>
       template<typename t = T, int n = N, typename std::enable_if<N == 2, void>::type* = nullptr>
       void g()
       {
           std::cout << "g()\n";
       }
   // ...
   

在这两种情况下，g() 拥有自己的模板参数，作为模板类的成员，函数模板参数必须与类模板参数分开。否则，函数的类模板将与类不匹配。

---

既然我们已经介绍了这一点，我应该指出 SFINAE 只涉及 立即 模板参数。因此，对于g() 使用带有N 的SFINAE，N 需要作为它的模板参数；否则，如果您尝试调用 A<float, 3>{}.g()，则会收到错误消息。如有必要，这可以通过中介来完成。

此外，您需要提供g() 的版本，当N != 2 时可以调用该版本。这是因为 SFINAE 仅适用于至少有一个有效版本的函数；如果无法调用g() 的任何版本，则会发出错误并且不会执行SFINAE。

template<typename T, int N>
class A
{
public:
    void f(void);

    // Note the use of "MyN".
    template<int MyN = N, typename std::enable_if<MyN == 2, void>::type* = nullptr>
    void g(void);

    // Note the "fail condition" overload.
    template<int MyN = N, typename std::enable_if<MyN != 2, void>::type* = nullptr>
    void g(void);
};

template<typename T, int N>
template<int MyN /*= N*/, typename std::enable_if<MyN == 2, void>::type* /* = nullptr */>
inline void A<T, N>::g()
{
    std::cout << "g()\n";
}

template<typename T, int N>
template<int MyN /*= N*/, typename std::enable_if<MyN != 2, void>::type* /* = nullptr */>
inline void A<T, N>::g()
{
    std::cout << "()g\n";
}

如果这样做，我们可以通过让中介完成繁重的工作来进一步简化事情。

template<typename T, int N>
class A
{
public:
    void f(void);

    template<bool B = (N == 2), typename std::enable_if<B, void>::type* = nullptr>
    void g(void);

    template<bool B = (N == 2), typename std::enable_if<!B, void>::type* = nullptr>
    void g(void);
};

// ...

看到它在行动here。

Answer 2

在第一个 sn-p 中，模板参数是 A，而您正在使用额外的参数重新声明它（这是一个错误）。
而且sfinae表达式涉及到类模板或函数模板，例子中没有。

在第二个 sn-p 模板中，参数是 g，现在是 sfinae 表达式正确应用的成员函数模板。

---

它遵循一个工作版本：

#include <type_traits>
#include <iostream>

template<typename T, int N>
class A
{
public:
    void f(void);

    template<int M = N>
    std::enable_if_t<M==2> g();
};

template<typename T, int N>
inline void A<T, N>::f()
{
    std::cout << "f()\n";
}

template<typename T, int N>
template<int M>
inline std::enable_if_t<M==2> A<T, N>::g()
{
    std::cout << "g()\n";
}

int main(int argc, char *argv[])
{
    A<float, 2> obj;
    obj.f(); // ok
    obj.g(); // ok (N==2)

    A<double,1> err;
    err.f(); // ok
    //err.g(); invalid (there is no g())

    return 0;
}

请注意，非类型参数必须在 sfinae 表达式的实际上下文中才能使后者起作用。
因此，template<int M = N> 是强制性的。

其他解决方案也适用。
例如，您可以使用导出f 的基类和添加g 的具有完全特化的派生模板类。