为什么 C++ 禁止这种部分特化？

Question

为什么 C++ 禁止这种部分特化？

这种禁忌背后的哲学是什么，我可以接受吗？
如果没有这种禁止，编程会容易得多。

模板应防止冗余。
现在我必须为 int d = 3 的每个类 N 产生冗余。

//__________________________________________
//__________________________________________
//
template<class N, int d>
class MyClass
{
public:
    void doo();
};

//__________________________________________
//__ allowed _______________________________
//
template<class N, int d>
void MyClass<N, d>::doo()
{
    cout << "general";
}

//__________________________________________
//__ forbidden _____________________________
//
template<class N>  
void MyClass<N, 3>::doo()
{
    cout << "partial specialization";
}

Answer 1

您首先需要对课程本身进行部分专业化。它是一个模板类。它的成员函数是一个非模板函数。类的部分特化可以在定义上有所不同。也就是说，它们可以有不同的成员集。

例如

template<class N, int d>
class MyClass
{
public:
    void doo();
};

template<class N, int d>
void MyClass<N, d>::doo()
{
    std::cout << "general";
}

template<class N>
class MyClass<N, 3>
{
public:
    void doo();
};

template<class N>  
void MyClass<N, 3>::doo()
{
    std::cout << "partial specialization";
}

对于函数模板，它们有自己的函数重载和函数特化机制。

Answer 2

您可以先对类进行部分特化，然后为特化类实现方法：

#include <iostream>

template<class N, int d>
class MyClass
{
public:
    void doo();
};

template<class N>
class MyClass<N, 3>
{
public:
    void doo();
};

template<class N, int d>
void MyClass<N, d>::doo()
{
    std::cout << "general\n";
}

template<class N>
void MyClass<N, 3>::doo()
{
    std::cout << "partial specialization\n";
}

int main()
{
    MyClass<int, 1> o1{}; o1.doo();
    MyClass<int, 3> o3{}; o3.doo();
}

// Outputs
//     general
//     partial specialization

Demo

Answer 3

函数的部分特化是一件非常棘手的事情，特别是如果你允许函数重载。

它可能导致无法特化的函数，或在意外重载时发生特化，或者永远无法调用特化。

我最好的建议是远离功能专业化。

对于你的问题，我想说，最好的办法是简单地使用 C++17 if constexpr:

template<class N, int d>
void MyClass<N, d>::doo()
{
    if constexpr (d != 3) {
        cout << "general";
    } else {
        cout << "only when d == 3";
    }
}

Answer 4

我过去经常依赖模式匹配，这使我经常受到语言的这种限制，对此我从未找到优雅实用的解决方案。 我想我本能地学会了避开这种设计，尽管我偶尔会偶然发现它。

我知道有四种解决方案：

1. 现代解决方案 (if constexpr)，（实用但不优雅的 IMO）。
2. 经典解决方案（在现实世界中不实用）。
3. 经典方案 + CRTP（实用但优雅？）
4. “深奥”的解决方案，enable_if（不是优雅的 IMO）

这篇文章主要阐述了数字 3。

这些解决方案都不是 100% 让我满意的。 我看不出语言在遇到专门的成员函数声明时不能只专门化模板类的根本原因，至少有限制。

---

现代解决方案（显示在一个答案中）是在通用版本中使用if constexpr。 我觉得这像是作弊，它并不优雅，我同意你的观点，必须有一种方法可以在模板中做到这一点。

---

经典的解决方案当然也是其他答案中所显示的。 但是我认为它不实用，原因是MyClass<N, 3> 在其声明和实现中通常看起来与一般情况MyClass<N, d> 非常相似，因此必须重复MyClass 的整个实现对于每个案例（部分）专业。 这是我无法接受的。

例如，考虑一下如果你有一个更复杂的类会发生什么：

template<class N, int d>
class MyClass
{
public:
    void A() const{....}
    void B() const{....}
    .
    .
    .
    void Z() const{....}
    void doo(){std::cout << "general";}
};

不一定，但您可能还需要有很多重复的代码：

template<class N>
class MyClass<N, 3>
{
    void A() const{....}
    void B() const{....}
    .
    .
    .
    void Z() const{....}
    void doo();
};

我想不出最坏的 DRY（不要重复自己）违规情况。

---

我找到的解决方法是提取MyClass的绝对公共部分：

template<class MyClassCRTP>
class BasicMyClass<MyClassCRTP> // eventually we need will need to know the derived class
{
public:
    void A() const{....}
    void B() const{....}
    .
    .
    .
    void Z() const{....}
};

template<class N, int d>
class MyClass : BasicMyClass<MyClass<N, d>>
{
public:
    void doo(){std::cout << "general";}
};

template<class N>
class MyClass<N, 3> : BasicMyClass<MyClass<N, 3>>
{
    void doo();
};

现在您可以专门化MyClass<N, 3>::doo 而无需太多重复代码。

这真的很优雅吗？我不知道。 它也确实打开了其他的蠕虫罐头。 当然不理想，我们想专门化一个（方法）函数，结果我们得到了额外的类！

---

最后，为了完整起见，深奥的解决方案，并不比 if constexpr 好，但有点向后兼容 IMO：

template<class N, int d>
class MyClass
{
public:
    template<class Dummy, std::enable_if<d != 3 and sizeof(Dummy*), int> = 0>
    void doo(){std::cout << "general";}
    template<class Dummy, std::enable_if<d == 3 and sizeof(Dummy*), int> = 0>
    void doo(){std::cout << "special";}
};