Thread: Overloading operators

This is binary +. *this will be the left-hand operand and a will be the right-hand operand.

Originally Posted by Niels_M

Why am I allowed to overload + in the aboce case, but no in the following case where I am using a non-member function?

I know the reason why example #2 does not work is because pointer-addition is not defined, but isn't that also what we are doing in example #1?

Because the evolution of the C++ language includes in its history, a few mistakes. One of them is that 'this' should have been a reference rather than a pointer.

As you know, calling any member function has an implicit 'this' pointer:

Code:

class foo {
public:
    int bar;
    void foobar() { cout << "woot!" << this->bar << endl; }
};

foo f;
f.foobar();

Here, foobar is called on an object, not a pointer, and yet C++ gives us use of 'this', which is a pointer.

We could just as easily have called it like this:

Code:

foo *pf;
pf = new foo();
pf->foobar();
delete pf;

However, here we're dereferencing pf using the -> operator to call the function, so we're essentially going from a pointer to what it points to, in order to make the call, losing all knowledge that the call even came from a pointer.

So basically, whether it is to an operator overload as a member function, or a plain old member function, the call is conceptually made on the object itself, not on a pointer.
Now, given that we could not have the implicit parameter being passed by value, clearly it must be passed by reference.

Conversion operators such as int usually is a bad idea. They do bad implicit conversions.

Originally Posted by Syscal

But yes, "a" is right hand side and "this" object is left hand side. Though I don't think you want to return void.

*cough*I think I know that. It was just an alternative.*cough*

Originally Posted by Niels_M

isn't that also what we are doing in example #1?

It is not, since as a member function, the left hand operand would be say, an object of the test class, not a pointer.

Why am I allowed to overload + in the aboce case, but no in the following case where I am using a non-member function?

If perhaps you did this:

Code:

void operator + (test *a)
{
   a->x += x;
}

Then the x's are added and the answer is stored in a, which is not necessarily what you want as

c = a + b;

is expected to work. Your operator is void, so we cannot depend on that.

If you wanted to go non-member non-friend then

Code:

const test & operator + (const test &a, const test &b)
{
   return test(a.getX() + b.getX());
}

is the binary + operator.

So the answers to your question include because your original operator has no return value, and because even if you wrote an operator outside, it needs access to the member x. There are many ways to safely access x, including accessor methods, or through use of the friend keyword. You could also make x public and not write an accessor, but then you will have to make sure not to use x inappropriately.

Originally Posted by Niels_M

But anon said in #2 that the left hand operand is the this-pointer.

Let's examine what anon really wrote in post #2:

Originally Posted by anon

*this will be the left-hand operand

anon did not write:

Originally Posted by Niels_M

the left hand operand is the this-pointer

I note that, whether it is a member or non-member, operator + should normally return the object by value, not by (const) reference, since the expected semantics is that a new object that is the "addition" of the operands is created. whiteflags' example erroneously returns a const reference to a local temporary.

If operator+ is available, it is often reasonable to expect that operator+= would also be available. As such, one approach is to implement operator+= as a member function, and then implement operator+ as a non-member non-friend function that makes use of operator+=, e.g.,

Code:

test operator+(test a, const test& b)
{
    return a += b;
}