创建超复杂类时操作符+优先级的问题

Question

我正在制作一个超复类只是为了练习，我有2个超复变量之间的算子+行为问题，我得到常规的复算子+，我还试图做2操作符+(1与Hc和复杂，第二与复杂和Hc，但这给了我模糊的eroor)

这是我的代码:

class Complex {
public:
Complex(const T& real = 0, const T& imaginary = 0);
Complex(const Complex&) = default;
virtual ~Complex() {};
Complex& operator=(const Complex&) = default;
Complex& operator+=(const Complex&);
}
protected:
T real;
T imaginary;
};
template <class T>
Complex<T>& Complex<T>::operator+=(const Complex<T>& rhs){
real += rhs.real;
imaginary += rhs.imaginary;
return *this;
}
template <class T>
Complex<T> operator+(const Complex<T>& lhs, const Complex<T>& rhs){
Complex<T> tmp = lhs;
return tmp += rhs; 
}
template <class T>
class HyperComplex: public Complex<T> {
private:
T j_part;
public :
HyperComplex(const T& real = 0, const T& imaginary = 0, const T& j_part = 0): Complex<T>(real,imaginary), j_part(j_part) {}    
HyperComplex(const HyperComplex&) = default;                                      
HyperComplex(const Complex<T>& p): Complex<T>(p) , j_part(0) {
const HyperComplex* ptr = dynamic_cast<const HyperComplex*>(&p);
if (ptr != nullptr){
j_part = ptr->j_part;
}
}    // copy ctor gets ref to complex
HyperComplex<T>& operator+=(const HyperComplex<T>& rhs){
this->real += rhs.real;
this->imaginary += rhs.imaginary;
j_part += rhs.j_part;
return *this;
}
};
template <class T>
HyperComplex<T> operator+(const HyperComplex<T>& lhs, const Complex<T>& rhs){
HyperComplex<T> tmp = lhs;
return tmp += rhs; 
}
template <class T>
HyperComplex<T> operator+(const Complex<T>& lhs, const HyperComplex<T>& rhs){
HyperComplex<T> tmp = rhs;
return tmp += lhs; 
}

当我运行这段代码时:

HyperComplex<int> hc(4,2,4) ;
HyperComplex<int> hc1 = hc + hc;
HyperComplex<int> hc2 = c2;
HyperComplex<int> hc3 = hc + c2;
HyperComplex<int> hc4 = c2 + hc;

我在hc1 calc

中有歧义

Answer 1

首先，类模板Complex的析构函数必须是虚的

virtual ~Complex() = default;

创建这个构造函数

HyperComplex(const Complex<T>& p);

明确

explicit HyperComplex(const Complex<T>& p);

否则，可以将类型为Complex的对象隐式地转换为类型为HyperComplex的对象，反之亦然。

的结果是操作符

template <class T>
Complex<T> operator+(const Complex<T>& lhs, const Complex<T>& rhs){
Complex<T> tmp = lhs;
return tmp += rhs; 
}

或运算符

template <class T>
HyperComplex<T> operator+(const HyperComplex<T>& lhs, const HyperComplex<T>& rhs){
HyperComplex<T> tmp = lhs;
return tmp += rhs; 
}

可以在下列语句中调用

HyperComplex<int> hc3 = hc + c2;
HyperComplex<int> hc4 = c2 + hc;

另一种方法是显式声明两个操作符，如

template <class T>
HyperComplex<T> operator+(const HyperComplex<T>& lhs, const Complex<T>& rhs);

和

template <class T>
HyperComplex<T> operator+(const Complex<T>& lhs, const HyperComplex<T>& rhs);

但是在任何情况下，带默认实参的类的构造函数都应该声明为显式的。

Answer 2

问题已修复!解决方案是4个不同的操作符+:

Complex<T> operator+(const Complex<T>& lhs, const Complex<T>& rhs){
Complex<T> tmp = lhs;
return tmp += rhs; 
}
template <class T>
HyperComplex<T> operator+(const HyperComplex<T>& lhs, const Complex<T>& rhs){
HyperComplex<T> tmp = lhs;
return tmp += rhs; 
}
template <class T>
HyperComplex<T> operator+(const Complex<T>& lhs, const HyperComplex<T>& rhs){
HyperComplex<T> tmp = rhs;
return tmp += lhs; 
}
template <class T>
HyperComplex<T> operator+(const HyperComplex<T>& lhs, const HyperComplex<T>& rhs){
HyperComplex<T> tmp = rhs;
return tmp += lhs; 
}