（类）偏特化Partial Specialization

当编写一个模板特化，涉及部分但不是全部模板参数时，它被称为偏特化（Partial Specialization）。【注意，偏特化是针对类模板而言，函数模板不可偏特化，只能全特化】
偏特化是C++模板编程中的一种技术，允许为特定类型或特定类型组合的模板参数创建专门的模板定义。这使得可以根据模板参数的特定属性或组合来定制模板的行为，从而提供更灵活和定制化的解决方案。

在偏特化中，可以保留模板参数中的一部分，而将另一部分替换为特定的类型或模式。这使得可以为不同的参数提供不同的实现，以满足特定的需求或条件。

偏特化在处理复杂的模板类型时特别有用，例如嵌套模板或带有多个模板参数的模板。通过偏特化可以根据具体情况对模板进行定制，而无需完全重新实现整个模板。

总的来说，偏特化是C++模板编程中的一项重要技术，允许根据特定的模板参数定制模板的行为，从而提供更灵活和高效的解决方案。

开始偏特化时，使用一个模板头列出没有特化的模板参数，然后定义特化。与完全特化一样，通过列出所有模板参数来命名要特化的类。一些模板参数取决于特化的参数，而另一些则使用特定值。

与完全特化一样，特化的定义完全替换了特定一组模板参数的主模板。按照惯例，保持相同的接口，但实际的实现不要求与原始模板一致。

偏特化示例：

#include <iostream>
#include <vector>

/* 1. 原始模板 */
template<class T, class U>
class Rational{
public:
    // Delegating Constructor
    Rational(): Rational(0){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
    Rational(T num): numerator_(num), denominator_(1){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
    Rational(T num, U den): numerator_(num), denominator_(den){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
    virtual ~Rational(){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

    T numerator()const{
        return numerator_;
    }

    U denominator()const{
        return denominator_;
    }

    template<class V>
    V calculate();

private:
    T numerator_;
    U denominator_;
};

template<class T, class U>
template<class V>
V Rational<T,U>::calculate(){
    return static_cast<V>(numerator_) / static_cast<V>(denominator_);  // omit divided by zero
}

/* 2. Partial Specialization，特化U为float */
template<class T>
class Rational<T, float>{
public:
    // Delegating Constructor
    Rational(): Rational(0){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
    Rational(T num): numerator_(num), denominator_(1){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
    Rational(T num, T den): numerator_(num), denominator_(den){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
    virtual ~Rational(){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

    T numerator()const{
        return numerator_;
    }

    float denominator()const{
        return denominator_;
    }

    template<class V>
    V calculate();

private:
    T numerator_;
    float denominator_;
};

template<class T>
template<class V>
V Rational<T,float>::calculate(){
    return static_cast<V>(numerator_) / static_cast<V>(denominator_);  // omit divided by zero
}

/* 3. Partial Specialization，特化T为float */
template<class U>
class Rational<float,U>{
public:
    // Delegating Constructor
    Rational(): Rational(0){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
    Rational(float num): numerator_(num), denominator_(1){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
    Rational(float num, U den): numerator_(num), denominator_(den){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
    virtual ~Rational(){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

    float numerator()const{
        return numerator_;
    }

    U denominator()const{
        return denominator_;
    }

    template<class V>
    V calculate();

private:
    float numerator_;
    U denominator_;
};

template<class U>
template<class V>
V Rational<float,U>::calculate(){
    return static_cast<V>(numerator_) / static_cast<V>(denominator_);  // omit divided by zero
}

int main() {
    Rational<float,int> r1;
    Rational<int,float> r2;
    Rational<int,int> r3;
    Rational<double,double> r4;
    //Rational<float,float> r5;  // 此句报错error: ambiguous template instantiation for 'class Rational<float, float>'
}