无法理解针对非专业类模板的形式的显式专业声明的规则

如何解决无法理解针对非专业类模板的形式的显式专业声明的规则

最新的c ++标准中针对非专业类模板的成员的显式专业声明的规则如下：

在对类模板的成员或出现在名称空间范围中的成员模板的显式专门化声明中，成员模板及其某些封闭的类模板可能保持非专门化，但声明不得显式专门化类成员模板（如果其周围的类模板也未明确专门化）。在这样的显式专门化声明中，应提供关键字template后跟template-parameter-list，而不是成员的显式专门化声明之前的template 。 template-parameter-list中的template-parameters类型应与主模板定义中指定的类型相同。

老实说，我对此段有很多困惑。请考虑下面的规则示例。

template <class T1> class A {
  template<class T2> class B {
    template<class T3> void mf1(T3);
    void mf2();
  };
};
template <class Y> 
template <>
void A<Y>::B<double>::mf2() { }   // error: B<double> is specialized but  
                                  // its enclosing class template A is not

正如评论所说，成员mf2的显式专门化声明格式不正确，但是，我不明白为什么通过此规则该替代形式格式不正确。我的理由是粗体措辞，它表示如果声明封闭的类模板也没有明确地专门化，则该声明不应明确地专门化类成员模板。但是，在此示例中，声明是mf2的显式特化，它不是类成员模板，而是类的成员。因此严格来讲，它不符合异常的条件，为什么声明的格式不正确？我觉得这一段不清楚。因此，深入研究，我发现了缺陷报告CWG529。

它说：

在对类模板的成员或出现在名称空间范围中的成员模板的显式专门化声明中，成员模板及其某些封闭的类模板可能保持非专业化，即，相应的模板前缀可以指定模板-parameter-list而不是template 以及使用这些模板参数作为模板参数编写命名模板的template-id。在这样的声明中，模板参数的数量，种类和类型应与主模板定义中指定的参数相同，并且模板参数应以它们出现的顺序在模板ID中命名。在template-parameter-list中。 在命名成员的合格ID中，非专业化的template-id不得位于模板专业名称的前面。

考虑了更多之后，我仍然认为该提案不足以解释这些情况，例如：

template <class T1> class A {
  template<class T2> class B {
    template<class T3> void mf1(T3);
    void mf2();
  };
};

template<>
template <class T> 
void A<int>::B<T>::mf2(){}

首先，mf2不是模板专长，但是模板ID B<T>在mf2之前，此声明格式错误。仍然无法解释该示例：

template <class T1> class A {
  template<class T2> class B {
    template<class T3> void mf1(T3);
    void mf2();
  };
};

template<>
template <class T> 
template <class U> 
void A<int>::B<T>::mf1(U){}

mf1是模板名称，而不是模板ID（即模板专业化）

因此，在思考了这些格式错误的示例之后，恕我直言，这句修饰词是否符合该规则的意图？

在对类模板的成员或出现在名称空间范围中的成员模板的显式专门化声明中，成员模板及其某些封闭的类模板可能保持未专门化的状态。在这样的显式专门化声明中，应提供关键字template后跟template-parameter-list，而不是成员的显式专门化声明之前的template 。 template-parameter-list中的template-parameters类型应与主模板定义中指定的类型相同。 在此声明中，嵌套名称说明符中未进行专门化的每个template-id应该是专门的。

template <class T1> class A {
  template<class T2> class B {
    template<class T3> 
    void mf1(T3);
    void mf2();
  };
};

template<>   // explicit specialization for `B`
template<class T>
class A<int>::B{
   template<class U>
   void mf1(U);
};

template<>
template<class T>
template <class U> 
void A<int>::B<T>::mf1(U){}

此示例格式不正确，尽管B<T>未专门化，但已明确专门化。这是一个很好的解释吗？或者，如果我误读了原始规则，请解释如何理解它。

解决方法

规则[temp.expl.spec]/p16递归地适用，它简单地说，除非导致它的整个链条也被专门化，否则没有什么可以被专门化。

我们甚至不涉足mf2，因为不可能针对每种可能的B专门研究A：

template <class T1> class A {
  template<class T2> class B {
    template<class T3> void mf1(T3);
    void mf2();
  };
};

template <class Y> 
template <>
void A<Y>::B<double>::mf2() { }  // Not OK - can't specialize B for every possible A

template <> 
template <>
void A<int>::B<double>::mf2() { }  // OK - full specialization

template <class T1> class A {
  template<class T2> class B {
    template<class T3> void mf1(T3);
    void mf2();
  };
};

template <>
template <class T> 
void A<int>::B<T>::mf2(){}

同一个故事：无法对mf2的每一个可能进行专门化。

最后一个带有专门的A<int>::B的示例有些令人困惑，但是同样的规则仍然适用：

A<int>::B

CWG 529试图解决以下事实：[temp.expl.spec]/p16中的措词令人困惑，因为它谈论的是嵌套类的“ specialization” ，而没有专门的术语。实际宣布。恕我直言，CWG 529无法承认在每个嵌套级别都有一个专门化的术语，只是假设性的。给出第一个示例：

template <class T1> class A {
template <class T2> class B {
    template<class T3> 
    void mf1(T3);
    void mf2();
};
};

template <>
template <class T>
class A<int>::B {   // explicit specialization for `B`
    template<class U>
    void mf1(U);
};

template <>
template <class T>
template <class U> 
void A<int>::B<T>::mf1(U){} // OK (not a specialization,but an out-of-line definition)

template <>
template <class T>
template <> 
void A<int>::B<T>::mf1(double){} // Not OK again,the entire chain must be specialized

template <>
template <>
template <> 
void A<int>::B<double>::mf1(double){} // OK - full specialization

没有template <class T1> class A { template<class T2> class B { template<class T3> void mf1(T3); void mf2(); }; }; template <class Y> template <> void A<Y>::B<double>::mf2() { } 。但是，如果有一个，它就不会进行编译（再次，不能为每个template <class Y> template <> class A<Y>::B {};专门化B）。