为什么允许嵌套类模板的部分特化，而不允许完全特化？

Question

    template<int x> struct A {                                                                                                    
        template<int y> struct B {};.                                                                                             
        template<int y, int unused> struct C {};                                                                                  
    };                                                                                                                            

    template<int x> template<> 
    struct A<x>::B<x> {}; // error: enclosing class templates are not explicitly specialized

    template<int x> template<int unused> 
    struct A<x>::C<x, unused> {}; // ok

那么，如果外部类也没有特化，为什么不允许内部嵌套类（或函数）的显式特化呢？奇怪的是，如果我只部分通过简单地添加一个虚拟模板参数来专门化内部类，我就可以解决这个问题。让事情变得更丑陋和更复杂，但它确实有效。

我会将完全特化视为部分特化的子集 - 特别是因为您可以通过添加虚拟参数将每个完整特化表示为部分特化。所以这种部分专业化和完全专业化之间的歧义对我来说真的没有意义。

不幸的是，comp.std.c++ 中没有人敢回答，所以我再次将它放在这里。

注意：对于一组外部类的内部类的递归模板，我需要此功能，并且内部参数的特殊化确实取决于外部模板参数。

Answer 1

我对为什么会发生这种情况的猜测：完整的特化不再是“模板类/函数”，它们是“真实的”类/方法，并且可以拥有真实的（链接器可见的）符号。但是对于部分专业化模板中的完全专业化模板，这是不正确的。 可能做出这个决定只是为了简化编译器编写者的生活（并且在此过程中让编码人员的生活更加困难：P）。

Answer 2

C++ 标准在第一种情况下明确禁止成员模板类的完全特化。根据 14.7.3/18：

在类模板或成员模板的成员的显式特化声明中出现 在命名空间范围内，成员模板和它的一些封闭类模板可能保持非特化， 除了声明 不应显式特化一个类成员模板，如果它的封闭类 模板也没有明确专门化。

Answer 3

您可以通过将实际工作委托给另一个结构来解决此问题：

namespace detail
{
  template <class T, class U>
  struct InnerImpl {};
}

template <class T>
struct Outer
{
  template <class U>
  struct Inner: detail::InnerImpl<T,U>
  {
  };
};

现在你可以随心所欲地专业化InnerImpl

Answer 4

支持 Virgil 的论点（他比我发布相同的理由更快），考虑一下：

template<typename T1>
class TOuter
  {
  public:
    template<typename T2>
    class TInner
      {
      public:
        T1 m_1;
        T2 m_2;
      };
  };

template<typename T1>
template<>
class TOuter<T1>::TInner<float>
  {
  public:
    T1    m_1;
    float m_2;
 };

由于 T1，TInner 是完全特化还是部分特化？

编辑：

在考虑了其他一些 cmets 之后 - 似乎您希望基于外部类中的模板参数进行完全专业化。如果嵌套内部类的实现，这似乎在 Visual Studio 2005 中有效：

template<typename T1>
class TOuter
  {
  public:
    template<typename T2>
    class TInner
      {
      public:
        std::string DoSomething() { return "Inner - general"; }
        T2 m_2;
      };

    template<>
    class TInner<T1>
      {
      public:
        std::string DoSomething() { return "Inner - special"; }
        T1 m_1;
      };
  };

TOuter::TInner 将正确地成为 TInner 的特化。我无法让它与模板之外的实现一起编译。