专门化成员模板而不专门化其父模板

Question

我有一个嵌套在另一个模板中的类模板。部分特化很容易：我只是在其父级中声明另一个 template< … > 块。

但是，我需要另一个偏特化来指定其所有本地模板参数。这使它成为一个明确的专业化。无论出于何种原因，显式特化必须在命名空间范围内。要在其父类之外声明它，必须指定父类，这需要一个非空的模板参数列表。这意味着部分专业化。部分专业化是我正在做的事情，它应该在任意外部范围内工作。但是 GCC 和 Comeau 都无法使用偏特化形式参数识别父提名中的模板参数。

template< class X > struct A {
    template< class Y > struct B; // initial declaration OK

    template< class Z >
    struct B< A< Z > > {}; // partial OK as long as there's a local arg

    template<> // ERROR: this syntax triggers explicit specialization
    struct B< int > {};
};

template<> // ERROR: can't nest template<>s here (why?)
template< class X > // ERROR: can't deduce X from type of A<X>::B<int> (why?)
struct A< X >::B< int > {};

（我把我所有的非工作代码都留在了；适当地注释它以试图理解。）

Answer 1

在 C++ 标准 14.7.3/18 下是非法的：

.... 声明不应显式特化类成员 模板，如果它的封闭类模板没有明确专门化 也是。

Answer 2

我倾向于不过多地使用嵌套类。我的主要抱怨是他们倾向于使嵌套类的代码膨胀。

因此我会提出另一种解决方法：

namespace detail
{
  template <class X, class Z> class BImpl;
  template <class X, class Z> class BImpl<X, A<Z> > {};
  template <class X> class BImpl<X,int> {};
}

template <class X>
class A
{
  template <class Z> struct B: BImpl<X,Z> {};
};

请注意，如果您还希望专门化 A，则需要将 X 作为参数传递给 BImpl。有趣的是，在这种情况下，我最终只获得了部分专业化！

Answer 3

复杂的东西。你的初始代码 ICE 的 VC10 Beta2，不错。

首先，我认为你有这个倒退：

template<> 
template< class X > 
struct A< X >::B< int > {};

X 是结构 A 的模板参数，而 B 是完全专用的，所以我认为应该是这样的：

template< class X > 
template<> 
struct A< X >::B< int > {};

但即使这样也无法编译。不过，错误文本实际上很有用：

a.cpp a.cpp(11)：错误 C3212： 'A::B' ：显式 模板成员的特化 必须是显式的成员 专业化 a.cpp(8) : 参见 'A::B' 的声明

如果你也完全专门化 A，那么完全专门化 B 似乎是合法的。

编辑：好的，我收到了可以对此发表权威意见的人的回复 - 换句话说，这是标准中一个非常模糊的区域，这是 C++ 委员会要清理的未解决问题it up（“it”是类模板成员的显式特化）。在短期内，建议是“不要那样做”。

Answer 4

至少这在 VC 2010 中有效。但是，我无法编写 def。类声明之外的“int”的fun()。 编辑：不幸的是 g++ 也有编译问题。 编辑：下面的代码适用于 VC 2010。

template<typename X>
class A
{
public:
    A()
    {

    }

    template<typename Y>
    struct B
    {
        void fun();
    };

    template<>
    struct B<int>
    {
        void fun()
        {
            cout << "Specialized version called\n";
        }
        //void fun();
    };



public:

    B<X> b;
};



template<typename X>
template<typename Y>
void A<X>::B<Y>::fun()
{
    cout << "templated version called\n";
}

int main()
{
   A<int> a;
    a.b.fun();
    A<float> a1;
    a1.b.fun();
}