Aghero - 9 months ago 52

C++ Question

I am trying to make a program that can opearate with complex numbers. However i got stuck with **operator *** I cannot figure out how to make these 2 cases work:

`First:`

c = 10 * d;

cout << c << endl;

Second:

c = d * 10;

cout << c << endl;

This is my header:

`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__ */

My idea was to use operator inside class for second case, and outside for first case. But I got error:

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

How to make it clear to compiler which overload to use?

My main is:

`#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 Source

In the first case, the `friend`

non-class method is invoked without ambiguity because first parameter is not a `Complex`

but can be built as such using the `double`

to `Complex`

constructor

In the second case, member method `*`

and `friend`

function can be applied, hence the error.

There's no need for a friend operator using 2 `Complex`

objects. It's only useful when first parameter is a non-class object / a class object where you cannot set/change the behaviour of `*`

You'd be better off with:

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

Notes:

- standard library has a very good
`std::complex`

implementation. - it would be better to use constant references rather than value parameter passing
- overloading member
`operator*(double s1)`

would be interesting to avoid converting to a`Complex`

when you want to multiply by a real value.