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

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 是非法的：

.... 声明不得显式特化类成员
template 如果它的封闭类模板没有显式专门化
以及。

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> {};
};

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

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++ 委员会清理它的一个开放问题（“它”是类模板成员的显式专业化）。短期内，建议是“不要这样做”。

Answer 4

至少这在 VC 2010 中有效。但是，我无法编写 def。 fun() 的“int”在类声明之外。
编辑：不幸的是 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();
}