C++ operator overload with friend

Question

I'm trying to achieve this using parameter overloading using C++:

Complex c(3.0, 4.0);
double magnitude = | c; // magnitude will be 5

I wrote the following code: (Only the necessary part here..)

class Complex
{
   public:
       double _real;
       double _imaginary;

       friend double operator|(const Complex &c1)
       {
           return sqrt(c1._real * c1._real + c1._imaginary * c1._imaginary);
       }
}

But I get the following error:

error C2805: binary 'operator |' has too few parameters

Is that impossible to use operator | with only 1 parameter?

Answer 1

friend double operator|(const Complex &c1)
{
    return sqrt(c1._real * c1._real + c1._imaginary * c1._imaginary);
}

This doesn't define a member operator, just FYI.

double magnitude = | c;

this is invalid syntax, | is a binary operator.

Correct way:

class Complex
{
   public:
       double _real;
       double _imaginary;

       double getMagnitude() const // POP POP!
       {
           return sqrt(_real * _real + _imaginary * _imaginary);
       }
}

No more bonus.

Answer 2

Is that impossible to use operator | with only 1 parameter?

You can overload operators as long as atleast one of the types involved is an user defined type but you cannot change the behavior w.r.t how many parameters they can take.
As the error message tells you | is a binary operator you cannot overload it to act as an unary operator.

What is the correct way to do this?

You should provide a utility function for your class Complex, do name it appropriately and it will to do the job for you in the best possible way.

Note that the very basic rule of operator overloading is:
"Whenever the meaning of an operator is not obviously clear and undisputed, it should not be overloaded. Instead, provide a function with a well-chosen name."
The rule is meant for non-intuitive operator usage like this.

Answer 3

operator| is a binary operator. As binary operator, it needs 2 parameters. If you want to do what you want to do here, you must use an unary operator.

Anyway - it looks like a bad idea since it is not obvious from looking at the operator to see what it does.

Answer 4

No - the '|' operator is a binary operator, meaning that it takes two parameters. You can overload operators but not change their "arity". Some operators are available with multiple arities though.

Unary operators include:

• +
• -
• ++ (both pre and post versions)
• -- (both pre and post versions)
• !
• ~
• *
• &
• (cast) (but you would have to define a suitable casting type to get your double result)

The best solution from a software engineering point of view would probably be an explicit method to get the modulus - e.g. getModulus(). But you could legitimately argue that a double cast is OK.

For the latter case, you would have:

class Complex
{
   public:
       double _real;
       double _imaginary;

       operator double() const
       {
           return sqrt(this._real * this._real + this._imaginary * this._imaginary);
       }
}

and use it as follows:

Complex c(3.0, 4.0);
double magnitude = c; // magnitude will be 5

Answer 5

Is that impossible to use operator | with only 1 parameter?

Yes. operator| is a binary operator. That means it takes two arguments. What you're looking for is operator|=

struct wtf
{
    double operator|= (double omg)
    {  
        return 42.;
    }
};

int main(){ wtf omg; omg|=  42.; }