嵌套 class 的部分特化

Question

如何在不部分专门化嵌套class的情况下部分专门化嵌套class ？

class C的实现对于所有N都是相同的。

C::iterator的实现对于N=1是特殊的。

template<class T, int N>
class C
{
    class iterator;
    ...
};

template<class T, int N>
class C<T, N>::iterator
{
    ...
};

// Partial specialization doesn't compile:
template<class T>
class C<T, 1>::iterator
{
    ...
};

我可以class C部分专业化为N=1 ，但这是很多代码重复......

Answer 1

如果您不想专门化整个 class 则只需将迭代器移出 class 并将其设为模板：

template<class T, int N>
class C_iterator
{
    ...
};

如果需要，使您的专业化：

template<class T>
class C_iterator<T, 1>
{
    ...
};

然后在您的 class 中使用它作为迭代器，如果需要，请与它成为朋友：

template<class T, int N>
class C
{
    using iterator = C_iterator<T, N>;
    friend iterator;
    ...
};

Answer 2

原因是：

template<class T>
class C<T, 1>::iterator {
    // ...
}

尝试成为 C 的部分特化的成员C iterator的定义，其中不存在这样的部分特化。 如果您使用非静态数据成员、成员 function 或成员模板尝试此操作，则会发生完全相同的问题：C++ 不允许部分特化，其中只有外部 ZA2F2ED4F8EBC2CBB4C21A29DC40AB6 是特化的。

例如，这编译：

template<class T, int N>
class C {
    class iterator;  // (A)
};

template<class T>
class C<T, 1> {
    class iterator;  // (B)
};

template<class T, int N>
class C<T, N>::iterator {};  // Definition for entity declared at (A)

template<class T>
class C<T, 1>::iterator {};  // Definition for entity declared at (B)  *not a partial template specialisation

而在 (B) 附近没有偏特化，则第二个定义没有任何定义。 作为一般的经验法则，部分特化只能引用最里面的实体，所以它必须是一个模板。

（请注意，这与实体iterator的类型无关：如果iterator是模板 class 并且您尝试基于N=1对其进行部分专门化，则会发生同样的问题）

---

所以最简单的答案是：你不能完全做你想做的事。

最简单的解决方案是 Öö Tiib 的回答是：将 class 取出并使iterator成为成员类型别名。

为了好玩，您可以将iterator设为模板 class 以便您可以对其进行部分专门化。 您仍然不能仅部分专门化外部 class ，因此我使用约束来模拟它：

template<class T, int N>
class C
{
    template<std::nullptr_t = nullptr>
    class iterator;
};

template<class T, int N>
template<std::nullptr_t>
class C<T, N>::iterator
{
};

template<class T, int N>
template<std::nullptr_t dummy> requires (N==1)
class C<T, N>::iterator<dummy>
{
};

// The first is a primary definition, the second a partial specialisation
// (Could have also made them both partial specialisations, with the first `requires (N!=1)`)

Answer 3

通过重新声明迭代器 class，可以得到相同的结果。

template<class T, int N>
class C
{
    class iterator {};
};

template<class T>
class C<T, 1>
{
    class iterator {};
};

它应与 class 的常用工作部分分开。 （除非你想重写它）

class CWorkDefine
{
    void func() {};
};

template<class T, int N>
class C : public CWorkDefine
{
    class iterator {};
};

template<class T>
class C<T, 1> : public CWorkDefine
{
    class iterator {};
};

下面的代码用于测试。

template<class T, int N>
class C
{
public:
    class iterator {};
};

// Partial specialization doesn't compile:
template<class T>
class C<T, 1>
{
public:
    class iterator { public: bool specialization; };
};

void test()
{
    C<int, 2>::iterator
    {
        
    };

    C<int, 1>::iterator
    {
        .specialization = true
    };
}