Оператор * перегрузка C++

Question

Я пытаюсь создать программу, которая может выполнять операции со сложными числами. Однако я застрял с оператора * Я не могу понять, как сделать эти 2 случая работы:

First: 
c = 10 * d; 
cout << c << endl; 
Second: 
c = d * 10; 
cout << c << endl; 

Это мой заголовок:

class Complex 
{ 
    private: 
     double Real, Imag; 
    public: 
     Complex() : Real(), Imag() 
     { 
     } 
    //---------------------------------------------------------------------- 
    Complex (double Real)  //Initialization with only one variable 
    { 
     this->Real = Real; 
     Imag = 0; 
    } 
    //---------------------------------------------------------------------- 
    Complex (double Real, double Imag)  //Complete initialization 
    { 
     this->Real = Real; 
     this->Imag = Imag; 
    } 
    //---------------------------------------------------------------------- 
    Complex & operator = (const Complex &s) 
    { 
     Real = s.Real; 
     Imag = s.Imag; 
     return *this; 
    } 
    //---------------------------------------------------------------------- 
    Complex operator * (Complex s) // (r + i) * x 
    { 
     this->Real *= s.Real; 
     this->Imag *= s.Real; 
     return *this; 
    } 
    //---------------------------------------------------------------------- 
    Complex & operator *= (Complex s)  //Reference 
    { 
     Real *= s.Real; 
     Imag *= s.Imag; 
     return *this; 
    } 
    //---------------------------------------------------------------------- 
    friend Complex operator * (Complex s1, Complex s2); 
    //---------------------------------------------------------------------- 
    friend ostream &operator << (ostream &s, const Complex &c)  
    { 
     s << c.Real << " + " << c.Imag; 
     return s; 
    } 
}; 
    //Out of class functions 
    inline Complex operator * (Complex s1, Complex s2)  // x * (r + i) 
    { 
     s2.Real *= s1.Real; 
     s2.Imag *= s1.Real; 
     return s2; 
    } 
    //---------------------------------------------------------------------- 
    bool Complex::operator == (const Complex &s) const 
    { 
     return (this->Real == s.Real && this->Imag == s.Imag); 
    } 
    //---------------------------------------------------------------------- 

#endif /* __Complex_H__ */ 

Моя идея состояла в том, чтобы использовать оператор внутри класса для второго случай и снаружи для первого случая. Но у меня была ошибка:

error: ambiguous overload for 'operator*' in 'd * 10 

Как прояснить компилятор, какой перегруз использовать?

Мои главным является:

#include <iostream> 
#include "complex.h" 

using namespace std; 

int main() 
{ 
    Complex c, d(3, 5); 
    c = 10 * d; 
    cout << c << endl; 
    c = d * 10; 
    cout << c << endl; 
} 

Answer 1

В первом случае метод friend внеклассового вызываются без двусмысленности, поскольку первый параметр не является Complex, но может быть построен как таковой с помощью double к Complex конструктору

Во втором случае могут применяться функции участника * и friend, поэтому ошибка.

Оператору не требуется использовать 2 Complex объектов. Это только полезно, если первый параметр не является классом объекта/объект класса, где вы не можете установить/изменить поведение *

Вы бы лучше с:

friend Complex operator * (double s1, const Complex &s2); 

Примечания:

• Стандартная библиотека имеет очень хорошую реализацию std::complex.
• было бы лучше использовать постоянные ссылки, а не параметр значения, проходящий
• перегрузки член operator*(double s1) было бы интересно, чтобы избежать преобразований в Complex, когда вы хотите, чтобы умножить на реальную стоимость.