Re: lvalue not needed for operator += : 5 += obj works
On Dec 21, 10:42 pm, "subramanian10...@yahoo.com, India"
<subramanian10...@yahoo.com> wrote:
Consider the following program:
#include <iostream>
#include <cstdlib>
using namespace std;
class Test
{
public:
Test(int arg = 10);
int val;
};
Test::Test(int arg) : val(arg)
{
cout << "one arg ctor called" << endl;
}
Test operator+=(Test lhs, Test rhs)
{
cout << "from operator+=" << endl;
return Test(lhs.val + rhs.val);
}
int main()
{
Test obj;
5 += obj;
return EXIT_SUCCESS;
}
This program compiles fine with both g++ and VC++ 2005 Express Edition
and both produced the following output:
one arg ctor called
one arg ctor called
from operator+=
one arg ctor called
My question:
Why doesn't the standard make the '+=', '-=', etc. be defined only as
non-static member functions similar to the way that an 'operator=,
operator[], operator(), and operator->' must be non-static member
function, so that it will disallow 5 += obj; (It should disallow
because the constant 5 appears on the left hand side)
Is there any advantage for the operators +=, -=, *=, etc be allowed as
non-member
functions ?
Kindly clarify
Thanks
V.Subramanian
Why should it disallow it, if you plan to shoot yourself in the foot,
its not the standard's concern.
If you are going to provide non-member operators like +=, its up to
you to provide something that makes sense.
You op+= does not use references and it returns a local copy. Why?
At the very least it should be modifying the lhs value and returning a
reference to it.
Interestingly enough, once you do that, the problem solves itself.
class Test
{
int val;
public:
Test(int arg = 10) : arg(val) { }
friend Test& operator+=(Test& lhs, const Test& rhs);
};
Test& operator+=(Test& lhs, const Test& rhs)
{
std::cout << "from operator+=" << std::endl;
lhs.val += rhs.val;
return lhs;
}
int main()
{
Test obj;
Test rhs;
obj += rhs; // obj.val = 20
// 5 += obj; // no match for op+=
}