CODEWITHSUNDEEP
c++operator-overloading
Kuba Spatny
Kuba Spatny

Reputation: 26990

Member vs Non-member operator overloading

I am trying to understand operator overloading in C++ and I ran into this piece of code:

class Imaginary {
    double re,im ;
    public:
    Imaginary ( double r, double i=0 ) : re(r), im(i) {}

    Imaginary operator - ( void ) const;                // member
    Imaginary operator + ( const Imaginary& x ) const;  // member

    friend Imaginary operator + ( double a, const Imaginary& b ); // non-member ?
};

which supposed to show the use of non-member overloading. But I don't understand how is it non-member when it's declared inside of class? Or does it depend on the number of parameter, as + is binary operation, so with 2 parameters it's considered non-member and with 1 member?

Upvotes: 0

Views: 372

Answers (3)

Vlad from Moscow
Vlad from Moscow

Reputation: 311088

There is a big difference between these two operators

Imaginary operator + ( const Imaginary& x ) const;  // member

friend Imaginary operator + ( double a, const Imaginary& b ); // non-member ?

In the first class member operator the left operand is always of type Imaginary. The second operand can be of type double because there is conversion constructor

Imaginary ( double r, double i=0 ) : re(r), im(i) {}

that allows implicitly convert a double value to an object of type Imaginary.

The friend operator allows to specify a double number as the first operand of the operation. Again if a double number will be specified as the first operand the conversion constructor will be called and in fact you will get expression

Imaginary + Imaginary.

Thus the friend operator appends the class member operator allowing the following expressions

Imaginary + Imaginary // class member operator will be called
Imaginary + double// class member operator will be called
double + Imaginary // the friend operator will be called

Upvotes: 0

Dietmar Kühl
Dietmar Kühl

Reputation: 154005

A friend declaration is injected into the namespace surrounding the class definition where it appears. That is, the declaration (namespace added to later clarification):

namespace foo {
    class Imaginary {
        // ...
        friend Imaginary operator+ (double a, Imaginary const& b);
    };
}

Actually does two things: it declares a function and it states that this function is allowed to access all members of the class Imaginary. The function declared is

foo::Imaginary foo::operator+ (double a, foo::Imaginary const& b);

Upvotes: 1

111111
111111

Reputation: 16168

This line declares op+ as a non-member friend. Meaning that despite it being a non member it can see Imaginary's private members.

friend Imaginary operator + ( double a, const Imaginary& b );

The implementation of the operator will be outside of the class.

Upvotes: 1

Related Questions