Re: assignment operator
On 2007-09-23 13:32, Michal Nazarewicz wrote:
On 2007-09-23 12:28, subramanian100in@yahoo.com, India wrote:
For a class Test, we write the assignment operator as
Test & Test::operator=(const Test & rhs);
instead of
const Test & Test::operator=(const Test & rhs);
that is, the return type of operator=( ) is just a reference, not a
reference to const object.
is it because to allow for expressions such as
(x = y) + z;
where x, y, z are of type Test ?
What would happen if we allowed "const Test &" as the return type of
Test::operator=( ) ?
Erik Wikstr??m <Erik-wikstrom@telia.com> writes:
I would say it is because there is no reason to return a const reference
(since the object referred to is not const) and it does allow us to do
some things that a const reference would not. Your example above "(x =
y) + z;", however, should work even with a const reference,
How come? There is no "operator=(const Test&)const", so how could it
work?
Because the plus operator should take const references as arguments and
be declared as const.
class Foo
{
public:
const Foo& operator=(const Foo& rhs) { return *this; }
Foo operator+(const Foo& rhs) const { return Foo(); }
};
int main()
{
Foo a, b, c;
Foo d = (a = b) + c;
Foo e = a + b;
}
the
following would not "(x = y) += z;", but on the other hand you should
probably write such code in the first place. Notice also that the other
unary operators, such as +=, *=, etc., return a non-const reference.
Those are not unary operators and they return the type you specify which
should be const reference.
Sorry, yes they are not unary operators, I meant assignments operators.
And of course they return whatever type you want them to return, but
they *should* return a non-const reference to themselves (or a type
which is convertible to that).
Programmers don't expect expressions such as "(a = b) = c" or "(a += b)
= c" to work and thus they should not work. Operator overloading is not
for creating new syntax.
I expect them to work, the most important thing when overloading
operators is to keep the semantics sane, which usually means that it
should be compatible with the semantics of built-in types. Of course it
is really bad style to actually use such code, but it should work.
--
Erik Wikstr??m