Передача различных параметров перегруженной функции оператора

Question

настоящее время у меня есть класс Complex:

class Complex{ 
public: 
    Complex(); 
    Complex(double, double); 
    double r, i; 
    void read(istream &in); 
    void display(ostream &out) const; 
    double real, imaginary; 

, что я использую, чтобы перегрузить оператор сложения. В настоящее время у меня есть три отдельные объявления функций для обработки 3 разных случаев: 2 комплексных числа, 1 комплексное число и 1 int справа, 1 int и 1 комплексное число справа.

Complex operator+ (const Complex& num1, const Complex& num2); 
Complex operator+ (const int num1, const Complex& num2); 
Complex operator+ (const Complex& num1,const int num2); 

объявления функций все просто сложить «реальные» и «мнимых» части комплексных чисел и добавить целые числа в действительные части комплексных чисел.

Complex operator+ (const Complex& num1,const Complex& num2) { 
    Complex result; 
    result.real += num1.real + num2.real; 
    result.imaginary += num1.imaginary +num2.imaginary; 
    return result; 
} 
Complex operator+ (const int num1, const Complex& num2){ 
    Complex result; 
    result.real += num1; 
    result.imaginary += num2.imaginary; 
    return result; 
} 
Complex operator+ (const Complex& num1, const int num2){ 
    Complex result; 
    result.real += num2; 
    result.imaginary += num1.imaginary; 
    return result; 
} 

Должен быть лучший способ сделать это правильно? Или все три случая должны быть явно объявлены?

Answer 1

Если вы добавите конструктор делегирования в класс Complex.

class Complex{ 
public: 
    Complex(); 
    Complex(double, double); 

    Complex(double a) : Complex(a, 0) {} 

Тогда вы обнаружите, что вам нужно определить только один operator+:

Complex operator+(const Complex &a, const Complex &b); 

И он будет обрабатывать все случаи использования в вашем примере.

Answer 2

Во-первых, код внутри ваших функций излишне сложный. Вы определенно должны инициализировать result, используя его конструктор с двумя аргументами, вместо инициализации до нуля и затем изменения. Например, код может быть:

Complex operator+ (const Complex& num1,const Complex& num2) 
{ 
    return Complex(num1.real + num2.real, num1.imaginary + num2.imaginary); 
} 

Complex operator+ (const Complex& num1, const int num2) 
{ 
    return Complex(num1.real + num2, num1.imaginary); 
} 

Complex operator+ (const int num1, const Complex& num2) 
{ 
    return num2 + num1; // compiler will inline this 
} 

Я не уверен, почему вы использовали int здесь, кажется, лучше всего использовать круглый double.

---

ответ Сэма показывает, как вы можете уменьшить три функции 1. Это уменьшает количество нажатий клавиш вы должны сделать, хотя это ввести небольшое снижение производительности: вы в конечном итоге делает дополнительный + 0.0 на возвращаемое значение-х imaginary.

Если мы смотрим вперед к умножению, то это наказание является немного более серьезным, например, код:

Complex operator*(Complex const &lhs, double rhs) 
{ 
    return Complex(lhs.real * rhs, lhs.imaginary * rhs); 
} 

на много меньше операций, чем, чем код внутри Complex operator*(Complex const &lhs, Complex const &rhs) будет делать.

Таким образом, вы должны сделать этот выбор между простотой и производительностью кода.