如何通过 SFINAE 测试类中是否存在内部类？

Question

我正在尝试为具有特定名称的内部类的类提供不同的模板特化。我从here 中获得了线索并尝试了以下方法：

#include <iostream>

template< typename T, typename Check = void > struct HasXYZ
{ static const bool value = false; };

template< typename T > struct HasXYZ< T, typename T::XYZ >
{ static const bool value = true; };

struct Foo
{
  class XYZ {};
};

struct FooWithTypedef
{
  typedef void XYZ;
};

int main()
{
  // The following line prints 1, as expected
  std::cout << HasXYZ< FooWithTypedef >::value << std::endl;
  // The following line prints 0. Why?
  std::cout << HasXYZ< Foo >::value << std::endl;

  return 0;
}

如您所见，如果我在FooWithTypedef 中测试typedef 定义的类型，它就可以工作。但是，如果类型是真正的内部类，则它不起作用。它也仅在FooWithTypedef 中的typedef-ed 类型与初始模板声明中第二个参数的默认值匹配时才有效（在我的示例中为void）。有人能解释一下这里发生了什么吗？专业化流程在这里如何运作？

Answer 1

回答最初的问题

您在此处定义的模板特化：

template <typename T> struct HasXYZ <T,typename T::XYZ>
{ static const bool value = true; };

当有人将数据类型HasXYZ<A,A::XYZ>用于某些数据类型A时才会生效。

请注意，无论A 是什么，A::XYZ 都是完全独立于A 的数据类型。内部类本身就是数据类型。当您使用A 作为第一个模板参数时，编译器绝对没有理由假设您想要使用名为A:XYZ 的东西作为第二个参数，即使存在该名称的内部类，并且即使这样做会导致编译器生成与模板参数完全匹配的模板特化。模板特化是根据编码器提供的模板参数找到的，而不是基于进一步的可能模板参数。

因此，当您使用HasXYZ<Foo> 时，它会回退到使用默认模板参数void 作为第二个参数。

不用说，如果你明确地使用HasXYZ<Foo,Foo:XYZ>，你会得到预期的输出。但这显然不是你想要的。

恐怕获得您需要的唯一方法是std::enable_if（或以类似方式工作的东西）。

---

回答附加问题（更新后）

考虑下面的简化：

template <typename T, typename Check = void>
struct A
{ static const bool value = false; };

template <typename T>
struct A<T,void>
{ static const bool value = true; };

主定义为第二个模板参数指定默认参数void。但是 specialization（上面的第二个定义）定义了 class A 在第二个模板参数真的 是 void 时的实际样子。

这意味着如果你在代码中使用A<int>，默认参数将被补充，所以你得到A<int,void>，然后编译器会找到最合适的模板特化，也就是第二个以上。

因此，虽然默认模板参数被定义为主模板声明的一部分，但使用它们并不意味着使用主模板定义。这基本上是因为默认模板参数是模板声明的一部分，而不是模板定义 (*)。

这就是为什么在你的例子中，当typedef void XYZ 包含在FooWithTypedef 中时，第二个模板参数默认为void，然后找到最合适的特化。即使在模板特化中第二个参数被定义为T::XYZ 而不是void，这仍然有效。如果在评估时这些相同，则将选择模板专业化（第 14.4 节“类型等效”）。

(*) 我没有在标准中找到这样清楚地说明它的声明。但是有 §14.1/10，它描述了您有多个模板声明（但只有一个主要定义）的情况：

(§14.1/10) 可用于模板声明或定义的默认模板参数集是通过将定义中的默认参数（如果在范围内）和范围内的所有声明以相同的方式默认合并获得的函数参数是（8.3.6）。 [ 例子：

  template<class T1, class T2 = int> class A;
  template<class T1 = int, class T2> class A;

等价于

  template<class T1 = int, class T2 = int> class A;

]。

这表明默认模板参数背后的机制独立于用于识别模板最合适特化的机制。

此外，还有两个现有的 SO 帖子也提到了这种机制：

This reply 到 Template specialization to use default type if class member typedef does not exist

Default values of template parameters in the class template specializations

Answer 2

这是另一个检测内部类存在的版本：

#include <iostream>

template< typename T >
struct HasXYZ
{
  typedef char                 yes;
  typedef struct{ char d[2]; } no;

  template<typename T1>
  static yes test( typename T1::XYZ * );
  template<typename T1>
  static no test(...);

  static const bool value = ( sizeof( test<T>(0) ) == sizeof( yes ) );
};

struct Foo
{
  class XYZ {};
};
struct Bar
{
  class ABC {};
};

int main()
{
  std::cout << std::boolalpha << HasXYZ< Foo >::value << std::endl;
  std::cout << std::boolalpha << HasXYZ< Bar >::value << std::endl;
}

Answer 3

A::XYZ 需要void 才能选择部分特化，而类类型永远不会出现这种情况。使其工作的一种方法是使用伪造的依赖 void 类型名：

template<class T>
struct void_{ typedef void type; };

template<class T, class = void>
struct has_XYZ{ static bool const value = false; };

template<class T>
struct has_XYZ<T, typename void_<typename T::XYZ>::type>{
  static bool const value = true;
};

有关其工作原理的说明，请参阅this question。