C++ c++；pimpl习惯用法：依赖于模板参数的实现

在中，我询问了如何根据模板参数使用不同的pimpl实现，但没有成功

也许这个例子更好地说明了我要做的事情：

#include <iostream>

template< int N, typename T >
struct B
{
    B() : c( new C< N > )
    {}

    template< int M >
    struct C;
    C< N > *c;
};

template< int N, typename T >
template< int M >
struct B< N, T >::C
{
    int a[M];
};

// version 1 that doesn't work    
    template< int N, typename T >
    template< >
    struct B< N, T >::C< 0 >
    {
        int a;
    };
// version 2 that doesn't work
    template< typename T >
    template< int M >
    struct B< 0, T >::C
    {
        int a;
    };


int main()
{
    B< 0, float >   b0;
    B< 1, int >     b1;

    std::cout << "b0 = " << sizeof(b0.c->a) << std::endl;
    std::cout << "b1 = " << sizeof(b1.c->a) << std::endl;
}

#包括
模板
结构B
{
B（）：c（新的c）
{}
模板
结构C；
C*C；
};
模板
模板
结构B：：C
{
int a[M]；
};
//版本1不起作用
模板
模板<>
结构B：C<0>
{
INTA；
};
//版本2不起作用
模板
模板
结构B<0，T>：：C
{
INTA；
};
int main（）
{
B<0，浮动>b0；
B<1，int>b1；
std：：cout语言不允许您尝试执行的操作

§14.7.3.16（FCD 2010-03-26）规定：

以明确的专业化
类成员的声明
模板或
出现在命名空间范围中，成员
模板及其一些封装
类模板可能会保留
非专业化，除了
声明不应明确
如果需要，则专门化类成员模板
它的封闭类模板不可用
也显式地专门化
如此明确的专业化
声明，关键字模板
后跟模板参数列表
应提供，而不是
显式
联合国专门化宣言
成员的类型
中的模板参数
模板参数清单应为
与主文件中指定的相同
模板定义

[示例：
模板类别A{
B类模板{
模板空隙mf1（T3）；
void mf2（）；
};
};
模板
A类：：B类{
模板空隙mf1（T）；
};
模板模板
void A:：B:：mf1（T）{
模板
void A:：B:：mf2（）{}//格式错误；B是专门化的，但
//它的封闭类模板A不是
-[结束示例]
该语言不允许您尝试执行的操作

§14.7.3.16（FCD 2010-03-26）规定：

以明确的专业化
类成员的声明
模板或
出现在命名空间范围中，成员
模板及其一些封装
类模板可能会保留
非专业化，除了
声明不应明确
如果需要，则专门化类成员模板
它的封闭类模板不可用
也显式地专门化
如此明确的专业化
声明，关键字模板
后跟模板参数列表
应提供，而不是
显式
联合国专门化宣言
成员的类型
中的模板参数
模板参数清单应为
与主文件中指定的相同
模板定义

[示例：
模板类别A{
B类模板{
模板空隙mf1（T3）；
void mf2（）；
};
};
模板
A类：：B类{
模板空隙mf1（T）；
};
模板模板
void A:：B:：mf1（T）{
模板
void A:：B:：mf2（）{}//格式错误；B是专门化的，但
//它的封闭类模板A不是
-[结束示例]
B:：C
的真正定义是否使用了
N
和/或
T
呢？如果没有，为什么它应该是类模板
B
的成员呢？@aschepler是的，它使用了，但这个例子只是简化了问题
B:：C
的真正定义是否使用了
N
和/或
T
呢？如果没有，为什么它是一个类模板<代码> b>代码>？@ ascPuple是的，它使用，但是这个例子只是简化了问题，顺便说一下，这是当前的C++标准中的7.7.3.18，这个段落回答了我的问题。顺便说一下，这是当前C++标准中的第7.7.3.18节，这段回答了我的问题。谢谢。
template< int M >
struct D
{
  int a[M];
};
template<  >
struct D<0>
{
  int a;
};

template< int N, typename T >
template< int M >
struct B< N, T >::C
{
    D< M > helper;
};

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

class A<int>::B {
    template <class T> void mf1(T);
};
template <> template <> template<class T>
void A<int>::B<double>::mf1(T t) { }
template <class Y> template <>
void A<Y>::B<double>::mf2() { } // ill-formed; B<double> is specialized but
// its enclosing class template A is not
—end example ]