Class 具有两个以上模板的类的方法中的部分规范

我有一个包含两个以上模板的类。现在，必须为其中两个模板专门化一个方法。作为一个最小的例子，我在一个类的方法中计算两个数的乘积，并取实部。数字应为复数或双精度。但是这个类总共有三个模板。以下是此操作的代码：

#include <complex>
#include <cmath>

template<typename T1, typename T2, typename T3>
class A{
    public:
        A(T1 const & a_, T2 const & b_, T3 const & c_);

    double multiply_and_real();

    private:

    T1 const & a;
    T2 const & b;
    T3 const & c;
};

template<typename T3>
class A: public A<double,double,T3> {};

template<typename T1, typename T2, typename T3>
A<T1,T2,T3>::A(T1 const & a_, T2 const & b_, T3 const & c_):
    a(a_),
    b(b_),
    c(c_)
    {}

template<typename T3>
double A<double,double,T3>::multiply_and_real(){

    return a*b;
}

template<typename T3>
double A<std::complex<double>,double,T3>::multiply_and_real(){

    return a.real()*b;
}

template<typename T3>
double A<double,std::complex<double,T3> >::multiply_and_real(){

    return a*b.real();
}

template<typename T3>
double A<std::complex<double,T3>,std::complex<double> >::multiply_and_real(){

    return a.real()*b.real();
}


template class A< double, double,double >;
template class A< std::complex<double>, double ,double >;
template class A< double,std::complex<double> ,double >;
template class A< std::complex<double>,std::complex<double> ,double >;

template class A< double, double,std::complex<double> >;
template class A< std::complex<double>, double ,std::complex<double> >;
template class A< double,std::complex<double> ,std::complex<double> >;
template class A< std::complex<double>,std::complex<double> ,std::complex<double> >;


int main(){


    return 0;
}

错误类型如下：

main3.cpp:19:7: error: redeclared with 1 template parameter
class A: public A<double,double,T3> {};

main3.cpp:5:7: note: previous declaration ‘template<class T1, class T2, class T3> class
A’ used 3 template parameters class A{

我还尝试通过以下方式直接指定类：

template<typename T3> class A< double, double,T3>;
template<typename T3> class A< std::complex<double>, double ,T3>;
template<typename T3> class A< double,std::complex<double> ,T3 >; 
template<typename T3> class A< std::complex<double>,std::complex<double> ,T3 >;

---

但这仍然会产生重新声明的错误。

错误来自第19行，在该行中，您定义了一个新的模板类a，其中包含一个模板参数，该参数从包含三个参数的模板类a继承而来。这个新类不能与旧类同名，这就是编译器抱怨的原因

如果您的实际应用程序具有与此类似的结构，则可以通过定义一个简单的函数（如

template <typename T>
double real_part(T a) {
    return 0;
}

template <>
double real_part(double a) {
    return a;
}

template <>
double real_part(std::complex<double> a) {
    return a.real();
}

然后您根本不需要指定乘法和实数的不同版本。你可以把它定义为

template<T1, T2, T3>
double A<T1, T2, T3> >::multiply_and_real() {
    return real_part(a) * real_part(b);
}

---

这正是我想要的：非常感谢！