Re: Overloaded operators
On 28 May, 02:25, Ulrich Eckhardt <dooms...@knuut.de> wrote:
Peithon wrote:
I'm writing overloading operators ( + and = ) for my class and a
wanted to ask about the return type
In general, what criteria determine whether it is
a) return by value or return by reference (I've read that assignment
operators should always return by ref)
b) const or non-const (I've read that when you return by value you
should make it const to simulate rvalue behaviour)
General rule is that you should make the operators similar in behaviour to
the builtin operators, this is the "principle of least surprise". The
exception is when the behaviour is drastically different, like e.g.
operators << and >> for streams or to some extent even operator+ for
strings, in such cases you can also change the behaviour, because above
principle doesn't apply anyway.
Now, operator+, how should it work? Just take as an example the way that an
integer behaves, then substitute with your class and modify the operators
accordingly till the code compiles and the results fit.
template<typename T>
void test_plus(T const& a, T const& b) {
T t1(a+b);
T t2(a+a);
T t4(a+b+a);
}
The above code will compile for T=int or T=float, just take it as base for
your tests.
Uli
--
[ Seehttp://www.gotw.ca/resources/clcm.htmfor info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]
Hi,
I like the "principle of least surprise" and I'll try that code. To
sum up:
a) return by value or return by reference? This resolves into 3 cases:
1 Return by value if the operator wants to return a local object which
would otherwise go out of scope, eg
class Widget{
public:
Widget operator+(const& Widget rhs)
{ return Widget(val + rhs.val) }
....
int val;
};
2 Return by reference for assignment operators =, +=, *=, etc because
the end result of an assignment should be the
left-hand operand, ie *this, not a copy of it
class Widget{
public:
Widget& operator=(const& Widget rhs)
{ if(this == &rhs)
return *this;
val = rhs.val;
return *this;
}
....
int val;
};
3 Otherwise, it's your choice based on efficiency (refs are cheaper)
and the behaviour you want.
b) const or non-const? This resolves into 2 cases:
1 If returning by value make it const to follow conventional
behaviour,
ie for built-in types, you can't assign to the result of a + b, ie (a
+ b) = c; should be illegal (see Scott Meyers Eff C++ Item 3)
Therefore, the operator+() above needs to be modified:
const Widget operator+(const& Widget rhs)
{ return Widget(val + rhs.val) }
2 If returning by reference, then default to const for safety unless
you want to allow the returned object to be changed.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]